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.8 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.11 by root, Mon Sep 11 20:26:41 2006 UTC

		1
1	/*	2	/*
2	* static char *rcsid_attack_c =	3	* static char *rcsid_attack_c =
3	* "$Id: attack.C,v 1.8 2006/09/03 00:18:42 root Exp $";	4	* "$Id: attack.C,v 1.11 2006/09/11 20:26:41 root Exp $";
4	*/	5	*/
		6
5	/*	7	/*
6	CrossFire, A Multiplayer game for X-windows	8	CrossFire, A Multiplayer game for X-windows
7		9
8	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	10	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
9	Copyright (C) 1992 Frank Tore Johansen	11	Copyright (C) 1992 Frank Tore Johansen
…		…
29	#include <living.h>	31	#include <living.h>
30	#include <material.h>	32	#include <material.h>
31	#include <skills.h>	33	#include <skills.h>
32		34
33	#ifndef __CEXTRACT__	35	#ifndef __CEXTRACT__
34	#include <sproto.h>	36	# include <sproto.h>
35	#endif	37	#endif
36		38
37	#include <sounds.h>	39	#include <sounds.h>
38		40
39	typedef struct att_msg_str {	41	typedef struct att_msg_str
		42	{
40	char *msg1;	43	char *msg1;
41	char *msg2;	44	char *msg2;
42	} att_msg;	45	} att_msg;
43		46
44	/*#define ATTACK_DEBUG*/	47	/*#define ATTACK_DEBUG*/
45		48
46	/* cancels object *op. Cancellation basically means an object loses	49	/* cancels object *op. Cancellation basically means an object loses
47	* its magical benefits.	50	* its magical benefits.
48	*/	51	*/
		52	void
49	void cancellation(object *op)	53	cancellation (object *op)
50	{	54	{
51	object *tmp;	55	object *tmp;
52		56
53	if (op->invisible)	57	if (op->invisible)
54	return;	58	return;
55		59
56	if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ) {	60	if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ)
		61	{
57	/* Recur through the inventory */	62	/* Recur through the inventory */
58	for(tmp=op->inv;tmp!=NULL;tmp=tmp->below)	63	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
59	if (!did_make_save_item(tmp, AT_CANCELLATION,op))	64	if (!did_make_save_item (tmp, AT_CANCELLATION, op))
60	cancellation(tmp);	65	cancellation (tmp);
61	}	66	}
62	else if(FABS(op->magic)<=(rndm(0, 5))) {	67	else if (FABS (op->magic) <= (rndm (0, 5)))
		68	{
63	/* Nullify this object. This code could probably be more complete */	69	/* Nullify this object. This code could probably be more complete */
64	/* in what abilities it should cancel */	70	/* in what abilities it should cancel */
65	op->magic=0;	71	op->magic = 0;
66	CLEAR_FLAG(op, FLAG_DAMNED);	72	CLEAR_FLAG (op, FLAG_DAMNED);
67	CLEAR_FLAG(op, FLAG_CURSED);	73	CLEAR_FLAG (op, FLAG_CURSED);
68	CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL);	74	CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);
69	CLEAR_FLAG(op, FLAG_KNOWN_CURSED);	75	CLEAR_FLAG (op, FLAG_KNOWN_CURSED);
70	if (op->env && op->env->type == PLAYER) {	76	if (op->env && op->env->type == PLAYER)
		77	{
71	esrv_send_item (op->env, op);	78	esrv_send_item (op->env, op);
72	}	79	}
73	}	80	}
74	}	81	}
75		82
76		83
…		…
78	/* did_make_save_item just checks to make sure the item actually	85	/* did_make_save_item just checks to make sure the item actually
79	* made its saving throw based on the tables. It does not take	86	* made its saving throw based on the tables. It does not take
80	* any further action (like destroying the item).	87	* any further action (like destroying the item).
81	*/	88	*/
82		89
		90	int
83	int did_make_save_item(object *op, int type, object *originator) {	91	did_make_save_item (object *op, int type, object *originator)
		92	{
84	int i, roll, saves=0, attacks=0, number;	93	int i, roll, saves = 0, attacks = 0, number;
85	materialtype_t *mt;	94	materialtype_t *mt;
86		95
87	if (op->materialname == NULL) {	96	if (op->materialname == NULL)
		97	{
88	for (mt = materialt; mt != NULL && mt->next != NULL; mt=mt->next) {	98	for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next)
		99	{
89	if (op->material & mt->material)	100	if (op->material & mt->material)
90	break;	101	break;
91	}	102	}
		103	}
92	} else	104	else
93	mt = name_to_material(op->materialname);	105	mt = name_to_material (op->materialname);
94	if (mt == NULL)	106	if (mt == NULL)
95	return TRUE;
96	roll = rndm(1, 20);
97
98	/* the attacktypes have no meaning for object saves
99	* If the type is only magic, don't adjust type - basically, if
100	* pure magic is hitting an object, it should save. However, if it
101	* is magic teamed with something else, then strip out the
102	* magic type, and instead let the fire, cold, or whatever component
103	* destroy the item. Otherwise, you get the case of poisoncloud
104	* destroying objects because it has magic attacktype.
105	*/
106	if (type != AT_MAGIC)
107	type &= ~(AT_CONFUSION|AT_DRAIN|AT_GHOSTHIT|AT_POISON|AT_SLOW|
108	AT_PARALYZE|AT_TURN_UNDEAD|AT_FEAR|AT_DEPLETE|AT_DEATH|
109	AT_COUNTERSPELL|AT_HOLYWORD|AT_BLIND|AT_LIFE_STEALING|
110	AT_MAGIC);
111
112	if (type == 0)
113	return TRUE;
114	if (roll == 20)
115	return TRUE;
116	if (roll == 1)
117	return FALSE;
118
119	for (number=0; number < NROFATTACKS; number++) {
120	i = 1<<number;
121	if (!(i&type))
122	continue;
123	attacks++;
124	if (op->resist[number] == 100)
125	saves++;
126	else if (roll >= mt->save[number] - op->magic - op->resist[number]/100)
127	saves++;
128	else if ((20-mt->save[number])/3 > originator->stats.dam)
129	saves++;
130	}
131
132	if (saves==attacks || attacks==0)
133	return TRUE;
134	if ((saves==0) || (rndm(1, attacks) > saves))
135	return FALSE;
136	return TRUE;	107	return TRUE;
		108	roll = rndm (1, 20);
		109
		110	/* the attacktypes have no meaning for object saves
		111	* 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
		113	* is magic teamed with something else, then strip out the
		114	* magic type, and instead let the fire, cold, or whatever component
		115	* destroy the item. Otherwise, you get the case of poisoncloud
		116	* destroying objects because it has magic attacktype.
		117	*/
		118	if (type != AT_MAGIC)
		119	type &= ~(AT_CONFUSION | AT_DRAIN | AT_GHOSTHIT | AT_POISON | AT_SLOW |
		120	AT_PARALYZE | AT_TURN_UNDEAD | AT_FEAR | AT_DEPLETE | AT_DEATH |
		121	AT_COUNTERSPELL | AT_HOLYWORD | AT_BLIND | AT_LIFE_STEALING | AT_MAGIC);
		122
		123	if (type == 0)
		124	return TRUE;
		125	if (roll == 20)
		126	return TRUE;
		127	if (roll == 1)
		128	return FALSE;
		129
		130	for (number = 0; number < NROFATTACKS; number++)
		131	{
		132	i = 1 << number;
		133	if (!(i & type))
		134	continue;
		135	attacks++;
		136	if (op->resist[number] == 100)
		137	saves++;
		138	else if (roll >= mt->save[number] - op->magic - op->resist[number] / 100)
		139	saves++;
		140	else if ((20 - mt->save[number]) / 3 > originator->stats.dam)
		141	saves++;
		142	}
		143
		144	if (saves == attacks || attacks == 0)
		145	return TRUE;
		146	if ((saves == 0) || (rndm (1, attacks) > saves))
		147	return FALSE;
		148	return TRUE;
137	}	149	}
138		150
139	/* This function calls did_make_save_item. It then performs the	151	/* This function calls did_make_save_item. It then performs the
140	* appropriate actions to the item (such as burning the item up,	152	* appropriate actions to the item (such as burning the item up,
141	* calling cancellation, etc.)	153	* calling cancellation, etc.)
142	*/	154	*/
143		155
		156	void
144	void save_throw_object (object *op, int type, object *originator)	157	save_throw_object (object *op, int type, object *originator)
145	{	158	{
146	if ( ! did_make_save_item (op, type,originator))	159	if (!did_make_save_item (op, type, originator))
147	{	160	{
148	object *env=op->env;	161	object *env = op->env;
149	int x=op->x,y=op->y;	162	int x = op->x, y = op->y;
150	mapstruct *m=op->map;	163	mapstruct *m = op->map;
151		164
152	op = stop_item (op);	165	op = stop_item (op);
153	if (op == NULL)	166	if (op == NULL)
154	return;	167	return;
155		168
156	/* Hacked the following so that type LIGHTER will work.	169	/* Hacked the following so that type LIGHTER will work.
157	* Also, objects which are potenital "lights" that are hit by	170	* Also, objects which are potenital "lights" that are hit by
158	* flame/elect attacks will be set to glow. "lights" are any	171	* flame/elect attacks will be set to glow. "lights" are any
159	* object with +/- glow_radius and an "other_arch" to change to.	172	* object with +/- glow_radius and an "other_arch" to change to.
160	* (and please note that we cant fail our save and reach this	173	* (and please note that we cant fail our save and reach this
161	* function if the object doesnt contain a material that can burn.	174	* function if the object doesnt contain a material that can burn.
162	* So forget lighting magical swords on fire with this!) -b.t.	175	* So forget lighting magical swords on fire with this!) -b.t.
163	*/	176	*/
164	if(type&(AT_FIRE|AT_ELECTRICITY)	177	if (type & (AT_FIRE | AT_ELECTRICITY) && op->other_arch && QUERY_FLAG (op, FLAG_IS_LIGHTABLE))
165	&&op->other_arch&&QUERY_FLAG(op, FLAG_IS_LIGHTABLE)) {	178	{
166	const char *arch=op->other_arch->name;	179	const char *arch = op->other_arch->name;
167		180
168	op = decrease_ob_nr (op, 1);	181	op = decrease_ob_nr (op, 1);
169	if (op)	182	if (op)
170	fix_stopped_item (op, m, originator);	183	fix_stopped_item (op, m, originator);
171	if((op = get_archetype(arch))!=NULL) {	184	if ((op = get_archetype (arch)) != NULL)
		185	{
172	if(env) {	186	if (env)
		187	{
173	op->x=env->x,op->y=env->y;	188	op->x = env->x, op->y = env->y;
174	insert_ob_in_ob(op,env);	189	insert_ob_in_ob (op, env);
175	if (env->contr)	190	if (env->contr)
176	esrv_send_item(env, op);	191	esrv_send_item (env, op);
177	} else {
178	op->x=x,op->y=y;
179	insert_ob_in_map(op,m,originator,0);
180	}
181	}	192	}
		193	else
182	return;	194	{
183	}	195	op->x = x, op->y = y;
184	if(type&AT_CANCELLATION) { /* Cancellation. */
185	cancellation(op);
186	fix_stopped_item (op, m, originator);
187	return;
188	}
189	if(op->nrof>1) {
190	op = decrease_ob_nr(op,rndm(0, op->nrof-1));
191	if (op)
192	fix_stopped_item (op, m, originator);	196	insert_ob_in_map (op, m, originator, 0);
193	} else {
194	if (op->env) {
195	object *tmp= is_player_inv(op->env);
196
197	if (tmp) {
198	esrv_del_item(tmp->contr, op->count);
199	}	197	}
200	}	198	}
		199	return;
		200	}
		201	if (type & AT_CANCELLATION)
		202	{ /* Cancellation. */
		203	cancellation (op);
		204	fix_stopped_item (op, m, originator);
		205	return;
		206	}
		207	if (op->nrof > 1)
		208	{
		209	op = decrease_ob_nr (op, rndm (0, op->nrof - 1));
		210	if (op)
		211	fix_stopped_item (op, m, originator);
		212	}
		213	else
		214	{
		215	if (op->env)
		216	{
		217	object *tmp = is_player_inv (op->env);
		218
		219	if (tmp)
		220	{
		221	esrv_del_item (tmp->contr, op->count);
		222	}
		223	}
201	if ( ! QUERY_FLAG (op, FLAG_REMOVED))	224	if (!QUERY_FLAG (op, FLAG_REMOVED))
202	remove_ob(op);	225	remove_ob (op);
203	free_object(op);	226	free_object (op);
204	}	227	}
205	if(type&(AT_FIRE|AT_ELECTRICITY)) {	228	if (type & (AT_FIRE | AT_ELECTRICITY))
		229	{
206	if(env) {	230	if (env)
		231	{
207	op=get_archetype("burnout");	232	op = get_archetype ("burnout");
208	op->x=env->x,op->y=env->y;	233	op->x = env->x, op->y = env->y;
209	insert_ob_in_ob(op,env);	234	insert_ob_in_ob (op, env);
		235	}
210	} else {	236	else
		237	{
211	replace_insert_ob_in_map("burnout",originator);	238	replace_insert_ob_in_map ("burnout", originator);
212	}	239	}
213	}	240	}
		241	return;
		242	}
		243	/* The value of 50 is arbitrary. */
		244	if (type & AT_COLD && (op->resist[ATNR_COLD] < 50) && !QUERY_FLAG (op, FLAG_NO_PICK) && (RANDOM () & 2))
		245	{
		246	object *tmp;
		247	archetype *at = find_archetype ("icecube");
		248
		249	if (at == NULL)
214	return;	250	return;
215	}
216	/* The value of 50 is arbitrary. */
217	if(type&AT_COLD &&(op->resist[ATNR_COLD]<50) &&
218	!QUERY_FLAG(op,FLAG_NO_PICK)&&(RANDOM()&2)) {
219	object *tmp;
220	archetype *at = find_archetype("icecube");
221	if (at == NULL)
222	return;
223	op = stop_item (op);	251	op = stop_item (op);
224	if (op == NULL)	252	if (op == NULL)
225	return;
226	if ((tmp = present_arch(at,op->map,op->x,op->y)) == NULL) {
227	tmp = arch_to_object(at);
228	tmp->x=op->x,tmp->y=op->y;
229	/* This was in the old (pre new movement code) -
230	* icecubes have slow_move set to 1 - don't want
231	* that for ones we create.
232	*/
233	tmp->move_slow_penalty=0;
234	tmp->move_slow=0;
235	insert_ob_in_map(tmp,op->map,originator,0);
236	}
237	if ( ! QUERY_FLAG (op, FLAG_REMOVED))
238	remove_ob(op);
239	(void) insert_ob_in_ob(op,tmp);
240	return;	253	return;
		254	if ((tmp = present_arch (at, op->map, op->x, op->y)) == NULL)
		255	{
		256	tmp = arch_to_object (at);
		257	tmp->x = op->x, tmp->y = op->y;
		258	/* This was in the old (pre new movement code) -
		259	* icecubes have slow_move set to 1 - don't want
		260	* that for ones we create.
		261	*/
		262	tmp->move_slow_penalty = 0;
		263	tmp->move_slow = 0;
		264	insert_ob_in_map (tmp, op->map, originator, 0);
		265	}
		266	if (!QUERY_FLAG (op, FLAG_REMOVED))
		267	remove_ob (op);
		268	(void) insert_ob_in_ob (op, tmp);
		269	return;
241	}	270	}
242	}	271	}
243		272
244	/* Object op is hitting the map.	273	/* Object op is hitting the map.
245	* op is going in direction 'dir'	274	* op is going in direction 'dir'
246	* type is the attacktype of the object.	275	* type is the attacktype of the object.
247	* full_hit is set if monster area does not matter.	276	* full_hit is set if monster area does not matter.
248	* returns 1 if it hits something, 0 otherwise.	277	* returns 1 if it hits something, 0 otherwise.
249	*/	278	*/
250		279
		280	int
251	int hit_map(object *op, int dir, int type, int full_hit) {	281	hit_map (object *op, int dir, int type, int full_hit)
		282	{
252	object *tmp, *next;	283	object *tmp, *next;
253	mapstruct *map;	284	mapstruct *map;
254	sint16 x, y;	285	sint16 x, y;
255	int retflag=0; /* added this flag.. will return 1 if it hits a monster */	286	int retflag = 0; /* added this flag.. will return 1 if it hits a monster */
256		287
257	tag_t op_tag, next_tag=0;	288	tag_t op_tag, next_tag = 0;
258		289
259	if (QUERY_FLAG (op, FLAG_FREED)) {	290	if (QUERY_FLAG (op, FLAG_FREED))
		291	{
260	LOG (llevError, "BUG: hit_map(): free object\n");	292	LOG (llevError, "BUG: hit_map(): free object\n");
		293	return 0;
		294	}
		295
		296	if (QUERY_FLAG (op, FLAG_REMOVED) || op->env != NULL)
		297	{
		298	LOG (llevError, "BUG: hit_map(): hitter (arch %s, name %s) not on a map\n", &op->arch->name, &op->name);
		299	return 0;
		300	}
		301
		302	if (!op->map)
		303	{
		304	LOG (llevError, "BUG: hit_map(): %s has no map\n", &op->name);
		305	return 0;
		306	}
		307
		308	if (op->head)
		309	op = op->head;
		310
		311	op_tag = op->count;
		312
		313	map = op->map;
		314	x = op->x + freearr_x[dir];
		315	y = op->y + freearr_y[dir];
		316
		317	int mflags = get_map_flags (map, &map, x, y, &x, &y);
		318
		319	// elmex: a safe map tile can't be hit!
		320	// this should prevent most harmful effects on items and players there.
		321	if (mflags & (P_OUT_OF_MAP | P_SAFE))
		322	return 0;
		323
		324	/* peterm: a few special cases for special attacktypes --counterspell
		325	* must be out here because it strikes things which are not alive
		326	*/
		327
		328	if (type & AT_COUNTERSPELL)
		329	{
		330	counterspell (op, dir); /* see spell_effect.c */
		331
		332	/* If the only attacktype is counterspell or magic, don't need
		333	* to do any further processing.
		334	*/
		335	if (!(type & ~(AT_COUNTERSPELL | AT_MAGIC)))
261	return 0;	336	return 0;
262	}
263		337
264	if (QUERY_FLAG (op, FLAG_REMOVED) || op->env != NULL) {
265	LOG (llevError, "BUG: hit_map(): hitter (arch %s, name %s) not on a map\n",
266	&op->arch->name, &op->name);
267	return 0;
268	}
269
270	if ( ! op->map) {
271	LOG (llevError,"BUG: hit_map(): %s has no map\n", &op->name);
272	return 0;
273	}
274
275	if (op->head) op=op->head;
276
277	op_tag = op->count;
278
279	map = op->map;
280	x = op->x + freearr_x[dir];
281	y = op->y + freearr_y[dir];
282
283	int mflags = get_map_flags(map, &map, x, y, &x, &y);
284	// elmex: a safe map tile can't be hit!
285	// this should prevent most harmful effects on items and players there.
286	if ((mflags & P_OUT_OF_MAP) || (mflags & P_SAFE))
287	return 0;
288
289	/* peterm: a few special cases for special attacktypes --counterspell
290	* must be out here because it strikes things which are not alive
291	*/
292
293	if (type & AT_COUNTERSPELL) {
294	counterspell(op,dir); /* see spell_effect.c */
295
296	/* If the only attacktype is counterspell or magic, don't need
297	* to do any further processing.
298	*/
299	if(!(type & ~(AT_COUNTERSPELL|AT_MAGIC))){
300	return 0;
301	}
302	type &= ~AT_COUNTERSPELL;	338	type &= ~AT_COUNTERSPELL;
303	}	339	}
304		340
305	if(type & AT_CHAOS){	341	if (type & AT_CHAOS)
		342	{
306	shuffle_attack(op,1); /*1 flag tells it to change the face */	343	shuffle_attack (op, 1); /*1 flag tells it to change the face */
307	update_object(op,UP_OBJ_FACE);	344	update_object (op, UP_OBJ_FACE);
308	type &= ~AT_CHAOS;	345	type &= ~AT_CHAOS;
309	}	346	}
310		347
311	next = get_map_ob (map, x, y);	348	next = get_map_ob (map, x, y);
		349	if (next)
		350	next_tag = next->count;
		351
		352	while (next)
		353	{
		354	if (was_destroyed (next, next_tag))
		355	{
		356	/* There may still be objects that were above 'next', but there is no
		357	* simple way to find out short of copying all object references and
		358	* tags into a temporary array before we start processing the first
		359	* object. That's why we just abort.
		360	*
		361	* This happens whenever attack spells (like fire) hit a pile
		362	* of objects. This is not a bug - nor an error. The errormessage
		363	* below was spamming the logs for absolutely no reason.
		364	*/
		365	/* LOG (llevDebug, "hit_map(): next object destroyed\n"); */
		366	break;
		367	}
		368
		369	tmp = next;
		370	next = tmp->above;
		371
312	if (next)	372	if (next)
313	next_tag = next->count;	373	next_tag = next->count;
314		374
315	while (next) {	375	if (QUERY_FLAG (tmp, FLAG_FREED))
		376	{
		377	LOG (llevError, "BUG: hit_map(): found freed object\n");
		378	break;
		379	}
		380
		381	/* Something could have happened to 'tmp' while 'tmp->below' was processed.
		382	* For example, 'tmp' was put in an icecube.
		383	* This is one of the few cases where on_same_map should not be used.
		384	*/
		385	if (tmp->map != map || tmp->x != x || tmp->y != y)
		386	continue;
		387
		388	if (QUERY_FLAG (tmp, FLAG_ALIVE))
		389	{
		390	hit_player (tmp, op->stats.dam, op, type, full_hit);
		391	retflag |= 1;
316	if (was_destroyed (next, next_tag)) {	392	if (was_destroyed (op, op_tag))
317	/* There may still be objects that were above 'next', but there is no
318	* simple way to find out short of copying all object references and
319	* tags into a temporary array before we start processing the first
320	* object. That's why we just abort.
321	*
322	* This happens whenever attack spells (like fire) hit a pile
323	* of objects. This is not a bug - nor an error. The errormessage
324	* below was spamming the logs for absolutely no reason.
325	*/
326	/* LOG (llevDebug, "hit_map(): next object destroyed\n"); */
327	break;	393	break;
328	}	394	}
329	tmp = next;
330	next = tmp->above;
331	if (next)
332	next_tag = next->count;
333		395
334	if (QUERY_FLAG (tmp, FLAG_FREED)) {	396	/* Here we are potentially destroying an object. If the object has
335	LOG (llevError, "BUG: hit_map(): found freed object\n");	397	* NO_PASS set, it is also immune - you can't destroy walls. Note
		398	* that weak walls have is_alive set, which prevent objects from
		399	* passing over/through them. We don't care what type of movement
		400	* the wall blocks - if it blocks any type of movement, can't be
		401	* destroyed right now.
		402	*/
		403	else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 && !tmp->move_block)
		404	{
		405	save_throw_object (tmp, type, op);
		406	if (was_destroyed (op, op_tag))
336	break;	407	break;
337	}	408	}
338
339	/* Something could have happened to 'tmp' while 'tmp->below' was processed.
340	* For example, 'tmp' was put in an icecube.
341	* This is one of the few cases where on_same_map should not be used.
342	*/
343	if (tmp->map != map || tmp->x != x || tmp->y != y)
344	continue;
345
346	if (QUERY_FLAG (tmp, FLAG_ALIVE)) {
347	hit_player(tmp,op->stats.dam,op,type,full_hit);
348	retflag |=1;
349	if (was_destroyed (op, op_tag))
350	break;
351	}
352	/* Here we are potentially destroying an object. If the object has
353	* NO_PASS set, it is also immune - you can't destroy walls. Note
354	* that weak walls have is_alive set, which prevent objects from
355	* passing over/through them. We don't care what type of movement
356	* the wall blocks - if it blocks any type of movement, can't be
357	* destroyed right now.
358	*/
359	else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 &&
360	!tmp->move_block) {
361	save_throw_object(tmp,type,op);
362	if (was_destroyed (op, op_tag))
363	break;
364	}
365	}	409	}
		410
366	return 0;	411	return 0;
367	}	412	}
368		413
		414	void
369	void attack_message(int dam, int type, object *op, object *hitter) {	415	attack_message (int dam, int type, object *op, object *hitter)
		416	{
370	char buf[MAX_BUF], buf1[MAX_BUF], buf2[MAX_BUF];	417	char buf[MAX_BUF], buf1[MAX_BUF], buf2[MAX_BUF];
371	int i, found=0;	418	int i, found = 0;
372	mapstruct *map;	419	mapstruct *map;
373	object *next, *tmp;	420	object *next, *tmp;
374		421
375	/* put in a few special messages for some of the common attacktypes	422	/* put in a few special messages for some of the common attacktypes
376	* a player might have. For example, fire, electric, cold, etc	423	* a player might have. For example, fire, electric, cold, etc
377	* [garbled 20010919]	424	* [garbled 20010919]
378	*/	425	*/
379		426
380	if (dam == 9998 && op->type == DOOR) {	427	if (dam == 9998 && op->type == DOOR)
		428	{
381	sprintf(buf1, "unlock %s", &op->name);	429	sprintf (buf1, "unlock %s", &op->name);
382	sprintf(buf2, " unlocks");	430	sprintf (buf2, " unlocks");
383	found++;	431	found++;
		432	}
		433	if (dam < 0)
384	}	434	{
385	if(dam<0) {
386	sprintf(buf1, "hit %s", &op->name);	435	sprintf (buf1, "hit %s", &op->name);
387	sprintf(buf2, " hits");	436	sprintf (buf2, " hits");
388	found++;	437	found++;
		438	}
389	} else if(dam==0) {	439	else if (dam == 0)
		440	{
390	sprintf(buf1, "missed %s", &op->name);	441	sprintf (buf1, "missed %s", &op->name);
391	sprintf(buf2, " misses");	442	sprintf (buf2, " misses");
392	found++;	443	found++;
		444	}
393	} else if ((hitter->type == DISEASE || hitter->type == SYMPTOM ||	445	else if ((hitter->type == DISEASE || hitter->type == SYMPTOM ||
394	hitter->type == POISONING ||	446	hitter->type == POISONING || (type & AT_POISON && IS_LIVE (op))) && !found)
395	(type & AT_POISON && IS_LIVE(op))) && !found) {	447	{
396	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1;	448	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1; i++)
397	i++)	449	if (dam < attack_mess[ATM_SUFFER][i].level || attack_mess[ATM_SUFFER][i + 1].level == -1)
398	if (dam < attack_mess[ATM_SUFFER][i].level	450	{
399	|| attack_mess[ATM_SUFFER][i+1].level == -1) {	451	sprintf (buf1, "%s %s%s", attack_mess[ATM_SUFFER][i].buf1, &op->name, attack_mess[ATM_SUFFER][i].buf2);
400	sprintf(buf1, "%s %s%s", attack_mess[ATM_SUFFER][i].buf1,
401	&op->name, attack_mess[ATM_SUFFER][i].buf2);
402	strcpy (buf2, attack_mess[ATM_SUFFER][i].buf3);	452	strcpy (buf2, attack_mess[ATM_SUFFER][i].buf3);
		453	found++;
		454	break;
		455	}
		456	}
		457	else if (op->type == DOOR && !found)
		458	{
		459	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_DOOR][i].level != -1; i++)
		460	if (dam < attack_mess[ATM_DOOR][i].level || attack_mess[ATM_DOOR][i + 1].level == -1)
		461	{
		462	sprintf (buf1, "%s %s%s", attack_mess[ATM_DOOR][i].buf1, &op->name, attack_mess[ATM_DOOR][i].buf2);
		463	strcpy (buf2, attack_mess[ATM_DOOR][i].buf3);
		464	found++;
		465	break;
		466	}
		467	}
		468	else if (hitter->type == PLAYER && IS_LIVE (op))
		469	{
		470	if (USING_SKILL (hitter, SK_KARATE))
		471	{
		472	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1; i++)
		473	if (dam < attack_mess[ATM_KARATE][i].level || attack_mess[ATM_KARATE][i + 1].level == -1)
		474	{
		475	sprintf (buf1, "%s %s%s", attack_mess[ATM_KARATE][i].buf1, &op->name, attack_mess[ATM_KARATE][i].buf2);
		476	strcpy (buf2, attack_mess[ATM_KARATE][i].buf3);
403	found++;	477	found++;
404	break;	478	break;
405	}	479	}
406	} else if (op->type == DOOR && !found) {	480	}
		481	else if (USING_SKILL (hitter, SK_CLAWING))
		482	{
407	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_DOOR][i].level != -1;	483	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_CLAW][i].level != -1; i++)
		484	if (dam < attack_mess[ATM_CLAW][i].level || attack_mess[ATM_CLAW][i + 1].level == -1)
408	i++)	485	{
409	if (dam < attack_mess[ATM_DOOR][i].level	486	sprintf (buf1, "%s %s%s", attack_mess[ATM_CLAW][i].buf1, &op->name, attack_mess[ATM_CLAW][i].buf2);
410	|| attack_mess[ATM_DOOR][i+1].level == -1) {
411	sprintf(buf1, "%s %s%s", attack_mess[ATM_DOOR][i].buf1,
412	&op->name, attack_mess[ATM_DOOR][i].buf2);
413	strcpy (buf2, attack_mess[ATM_DOOR][i].buf3);	487	strcpy (buf2, attack_mess[ATM_CLAW][i].buf3);
414	found++;	488	found++;
415	break;	489	break;
416	}
417	} else if (hitter->type == PLAYER && IS_LIVE(op)) {
418	if (USING_SKILL(hitter, SK_KARATE)) {
419	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1;
420	i++)
421	if (dam < attack_mess[ATM_KARATE][i].level
422	|| attack_mess[ATM_KARATE][i+1].level == -1) {
423	sprintf(buf1, "%s %s%s", attack_mess[ATM_KARATE][i].buf1,
424	&op->name, attack_mess[ATM_KARATE][i].buf2);
425	strcpy (buf2, attack_mess[ATM_KARATE][i].buf3);
426	found++;
427	break;
428	}	490	}
429	} else if (USING_SKILL(hitter, SK_CLAWING)) {
430	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_CLAW][i].level != -1;
431	i++)
432	if (dam < attack_mess[ATM_CLAW][i].level
433	|| attack_mess[ATM_CLAW][i+1].level == -1) {
434	sprintf(buf1, "%s %s%s", attack_mess[ATM_CLAW][i].buf1,
435	&op->name, attack_mess[ATM_CLAW][i].buf2);
436	strcpy (buf2, attack_mess[ATM_CLAW][i].buf3);
437	found++;
438	break;
439	}	491	}
440	} else if (USING_SKILL(hitter, SK_PUNCHING)) {	492	else if (USING_SKILL (hitter, SK_PUNCHING))
		493	{
441	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_PUNCH][i].level != -1;	494	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_PUNCH][i].level != -1; i++)
		495	if (dam < attack_mess[ATM_PUNCH][i].level || attack_mess[ATM_PUNCH][i + 1].level == -1)
442	i++)	496	{
443	if (dam < attack_mess[ATM_PUNCH][i].level
444	|| attack_mess[ATM_PUNCH][i+1].level == -1) {
445	sprintf(buf1, "%s %s%s", attack_mess[ATM_PUNCH][i].buf1,	497	sprintf (buf1, "%s %s%s", attack_mess[ATM_PUNCH][i].buf1, &op->name, attack_mess[ATM_PUNCH][i].buf2);
446	&op->name, attack_mess[ATM_PUNCH][i].buf2);
447	strcpy (buf2, attack_mess[ATM_PUNCH][i].buf3);	498	strcpy (buf2, attack_mess[ATM_PUNCH][i].buf3);
448	found++;
449	break;
450	}
451	}
452	}
453	if (found) {
454	/* done */
455	} else if (IS_ARROW(hitter) && (type == AT_PHYSICAL || type == AT_MAGIC)) {
456	sprintf(buf1, "hit"); /* just in case */
457	for (i=0; i < MAXATTACKMESS; i++)
458	if (dam < attack_mess[ATM_ARROW][i].level
459	|| attack_mess[ATM_ARROW][i+1].level == -1) {
460	strcpy (buf2, attack_mess[ATM_ARROW][i].buf3);
461	found++;	499	found++;
462	break;	500	break;
		501	}
		502	}
		503	}
		504	if (found)
		505	{
		506	/* done */
		507	}
		508	else if (IS_ARROW (hitter) && (type == AT_PHYSICAL || type == AT_MAGIC))
		509	{
		510	sprintf (buf1, "hit"); /* just in case */
		511	for (i = 0; i < MAXATTACKMESS; i++)
		512	if (dam < attack_mess[ATM_ARROW][i].level || attack_mess[ATM_ARROW][i + 1].level == -1)
		513	{
		514	strcpy (buf2, attack_mess[ATM_ARROW][i].buf3);
		515	found++;
		516	break;
		517	}
		518	}
		519	else if (type & AT_DRAIN && IS_LIVE (op))
		520	{
		521	/* drain is first, because some items have multiple attypes */
		522	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1; i++)
		523	if (dam < attack_mess[ATM_DRAIN][i].level || attack_mess[ATM_DRAIN][i + 1].level == -1)
		524	{
		525	sprintf (buf1, "%s %s%s", attack_mess[ATM_DRAIN][i].buf1, &op->name, attack_mess[ATM_DRAIN][i].buf2);
		526	strcpy (buf2, attack_mess[ATM_DRAIN][i].buf3);
		527	found++;
		528	break;
		529	}
		530	}
		531	else if (type & AT_ELECTRICITY && IS_LIVE (op))
		532	{
		533	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1; i++)
		534	if (dam < attack_mess[ATM_ELEC][i].level || attack_mess[ATM_ELEC][i + 1].level == -1)
		535	{
		536	sprintf (buf1, "%s %s%s", attack_mess[ATM_ELEC][i].buf1, &op->name, attack_mess[ATM_ELEC][i].buf2);
		537	strcpy (buf2, attack_mess[ATM_ELEC][i].buf3);
		538	found++;
		539	break;
		540	}
		541	}
		542	else if (type & AT_COLD && IS_LIVE (op))
		543	{
		544	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1; i++)
		545	if (dam < attack_mess[ATM_COLD][i].level || attack_mess[ATM_COLD][i + 1].level == -1)
		546	{
		547	sprintf (buf1, "%s %s%s", attack_mess[ATM_COLD][i].buf1, &op->name, attack_mess[ATM_COLD][i].buf2);
		548	strcpy (buf2, attack_mess[ATM_COLD][i].buf3);
		549	found++;
		550	break;
		551	}
		552	}
		553	else if (type & AT_FIRE)
		554	{
		555	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_FIRE][i].level != -1; i++)
		556	if (dam < attack_mess[ATM_FIRE][i].level || attack_mess[ATM_FIRE][i + 1].level == -1)
		557	{
		558	sprintf (buf1, "%s %s%s", attack_mess[ATM_FIRE][i].buf1, &op->name, attack_mess[ATM_FIRE][i].buf2);
		559	strcpy (buf2, attack_mess[ATM_FIRE][i].buf3);
		560	found++;
		561	break;
		562	}
		563	}
		564	else if (hitter->current_weapon != NULL)
		565	{
		566	int mtype;
		567
		568	switch (hitter->current_weapon->weapontype)
		569	{
		570	case WEAP_HIT:
		571	mtype = ATM_BASIC;
		572	break;
		573	case WEAP_SLASH:
		574	mtype = ATM_SLASH;
		575	break;
		576	case WEAP_PIERCE:
		577	mtype = ATM_PIERCE;
		578	break;
		579	case WEAP_CLEAVE:
		580	mtype = ATM_CLEAVE;
		581	break;
		582	case WEAP_SLICE:
		583	mtype = ATM_SLICE;
		584	break;
		585	case WEAP_STAB:
		586	mtype = ATM_STAB;
		587	break;
		588	case WEAP_WHIP:
		589	mtype = ATM_WHIP;
		590	break;
		591	case WEAP_CRUSH:
		592	mtype = ATM_CRUSH;
		593	break;
		594	case WEAP_BLUD:
		595	mtype = ATM_BLUD;
		596	break;
		597	default:
		598	mtype = ATM_BASIC;
		599	break;
		600	}
		601	for (i = 0; i < MAXATTACKMESS && attack_mess[mtype][i].level != -1; i++)
		602	if (dam < attack_mess[mtype][i].level || attack_mess[mtype][i + 1].level == -1)
		603	{
		604	sprintf (buf1, "%s %s%s", attack_mess[mtype][i].buf1, &op->name, attack_mess[mtype][i].buf2);
		605	strcpy (buf2, attack_mess[mtype][i].buf3);
		606	found++;
		607	break;
		608	}
		609	}
		610	else
		611	{
		612	for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_BASIC][i].level != -1; i++)
		613	if (dam < attack_mess[ATM_BASIC][i].level || attack_mess[ATM_BASIC][i + 1].level == -1)
		614	{
		615	sprintf (buf1, "%s %s%s", attack_mess[ATM_BASIC][i].buf1, &op->name, attack_mess[ATM_BASIC][i].buf2);
		616	strcpy (buf2, attack_mess[ATM_BASIC][i].buf3);
		617	found++;
		618	break;
		619	}
		620	}
		621
		622	if (!found)
		623	{
		624	strcpy (buf1, "hit");
		625	strcpy (buf2, " hits");
		626	}
		627
		628	/* bail out if a monster is casting spells */
		629	if (!(hitter->type == PLAYER || (get_owner (hitter) != NULL && hitter->owner->type == PLAYER)))
		630	return;
		631
		632	/* scale down magic considerably. */
		633	if (type & AT_MAGIC && rndm (0, 5))
		634	return;
		635
		636	/* Did a player hurt another player? Inform both! */
		637	if (op->type == PLAYER && (get_owner (hitter) == NULL ? hitter->type : hitter->owner->type) == PLAYER)
		638	{
		639	if (get_owner (hitter) != NULL)
		640	sprintf (buf, "%s's %s%s you.", &hitter->owner->name, &hitter->name, buf2);
		641	else
		642	{
		643	sprintf (buf, "%s%s you.", &hitter->name, buf2);
		644	if (dam != 0)
		645	{
		646	if (dam < 10)
		647	play_sound_player_only (op->contr, SOUND_PLAYER_IS_HIT1, 0, 0);
		648	else if (dam < 20)
		649	play_sound_player_only (op->contr, SOUND_PLAYER_IS_HIT2, 0, 0);
		650	else
		651	play_sound_player_only (op->contr, SOUND_PLAYER_IS_HIT3, 0, 0);
463	}	652	}
464	} else if (type & AT_DRAIN && IS_LIVE(op)) {
465	/* drain is first, because some items have multiple attypes */
466	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1;
467	i++)
468	if (dam < attack_mess[ATM_DRAIN][i].level
469	|| attack_mess[ATM_DRAIN][i+1].level == -1) {
470	sprintf(buf1, "%s %s%s", attack_mess[ATM_DRAIN][i].buf1,
471	&op->name, attack_mess[ATM_DRAIN][i].buf2);
472	strcpy (buf2, attack_mess[ATM_DRAIN][i].buf3);
473	found++;
474	break;
475	}	653	}
476	} else if (type & AT_ELECTRICITY && IS_LIVE(op)) {
477	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1;
478	i++)
479	if (dam < attack_mess[ATM_ELEC][i].level
480	|| attack_mess[ATM_ELEC][i+1].level == -1) {
481	sprintf(buf1, "%s %s%s", attack_mess[ATM_ELEC][i].buf1,
482	&op->name, attack_mess[ATM_ELEC][i].buf2);
483	strcpy (buf2, attack_mess[ATM_ELEC][i].buf3);
484	found++;
485	break;
486	}
487	} else if (type & AT_COLD && IS_LIVE(op)) {
488	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1;
489	i++)
490	if (dam < attack_mess[ATM_COLD][i].level
491	|| attack_mess[ATM_COLD][i+1].level == -1) {
492	sprintf(buf1, "%s %s%s", attack_mess[ATM_COLD][i].buf1,
493	&op->name, attack_mess[ATM_COLD][i].buf2);
494	strcpy (buf2, attack_mess[ATM_COLD][i].buf3);
495	found++;
496	break;
497	}
498	} else if (type & AT_FIRE) {
499	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_FIRE][i].level != -1;
500	i++)
501	if (dam < attack_mess[ATM_FIRE][i].level
502	|| attack_mess[ATM_FIRE][i+1].level == -1) {
503	sprintf(buf1, "%s %s%s", attack_mess[ATM_FIRE][i].buf1,
504	&op->name, attack_mess[ATM_FIRE][i].buf2);
505	strcpy (buf2, attack_mess[ATM_FIRE][i].buf3);
506	found++;
507	break;
508	}
509	} else if (hitter->current_weapon != NULL) {
510	int mtype;
511	switch (hitter->current_weapon->weapontype) {
512	case WEAP_HIT: mtype = ATM_BASIC; break;
513	case WEAP_SLASH: mtype = ATM_SLASH; break;
514	case WEAP_PIERCE: mtype = ATM_PIERCE; break;
515	case WEAP_CLEAVE: mtype = ATM_CLEAVE; break;
516	case WEAP_SLICE: mtype = ATM_SLICE; break;
517	case WEAP_STAB: mtype = ATM_STAB; break;
518	case WEAP_WHIP: mtype = ATM_WHIP; break;
519	case WEAP_CRUSH: mtype = ATM_CRUSH; break;
520	case WEAP_BLUD: mtype = ATM_BLUD; break;
521	default: mtype = ATM_BASIC; break;
522	}
523	for (i=0; i < MAXATTACKMESS && attack_mess[mtype][i].level != -1;
524	i++)
525	if (dam < attack_mess[mtype][i].level
526	|| attack_mess[mtype][i+1].level == -1) {
527	sprintf(buf1, "%s %s%s", attack_mess[mtype][i].buf1,
528	&op->name, attack_mess[mtype][i].buf2);
529	strcpy (buf2, attack_mess[mtype][i].buf3);
530	found++;
531	break;
532	}
533	} else {
534	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_BASIC][i].level != -1;
535	i++)
536	if (dam < attack_mess[ATM_BASIC][i].level
537	|| attack_mess[ATM_BASIC][i+1].level == -1) {
538	sprintf(buf1, "%s %s%s", attack_mess[ATM_BASIC][i].buf1,
539	&op->name, attack_mess[ATM_BASIC][i].buf2);
540	strcpy (buf2, attack_mess[ATM_BASIC][i].buf3);
541	found++;
542	break;
543	}
544	}
545
546	if (!found) {
547	strcpy (buf1, "hit");
548	strcpy (buf2, " hits");
549	}
550
551	/* bail out if a monster is casting spells */
552	if (!(hitter->type == PLAYER ||
553	(get_owner(hitter) != NULL && hitter->owner->type == PLAYER)))
554	return;
555
556	/* scale down magic considerably. */
557	if (type & AT_MAGIC && rndm(0, 5))
558	return;
559
560	/* Did a player hurt another player? Inform both! */
561	if(op->type==PLAYER &&
562	(get_owner(hitter)==NULL?hitter->type:hitter->owner->type)==PLAYER) {
563	if(get_owner(hitter)!=NULL)
564	sprintf(buf,"%s's %s%s you.",
565	&hitter->owner->name, &hitter->name, buf2);
566	else {
567	sprintf(buf,"%s%s you.", &hitter->name, buf2);
568	if (dam != 0) {
569	if (dam < 10)
570	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT1,0,0);
571	else if (dam < 20)
572	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT2,0,0);
573	else
574	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT3,0,0);
575	}
576	}
577	new_draw_info(NDI_BLACK, 0,op,buf);	654	new_draw_info (NDI_BLACK, 0, op, buf);
578	} /* end of player hitting player */	655	} /* end of player hitting player */
579		656
580	if(hitter->type==PLAYER) {	657	if (hitter->type == PLAYER)
		658	{
581	sprintf(buf,"You %s.",buf1);	659	sprintf (buf, "You %s.", buf1);
582	if (dam != 0) {	660	if (dam != 0)
		661	{
583	if (dam < 10)	662	if (dam < 10)
584	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS1,0,0);	663	play_sound_player_only (hitter->contr, SOUND_PLAYER_HITS1, 0, 0);
585	else if (dam < 20)	664	else if (dam < 20)
586	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS2,0,0);	665	play_sound_player_only (hitter->contr, SOUND_PLAYER_HITS2, 0, 0);
587	else	666	else
588	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS3,0,0);	667	play_sound_player_only (hitter->contr, SOUND_PLAYER_HITS3, 0, 0);
589	}	668	}
590	new_draw_info(NDI_BLACK, 0, hitter, buf);	669	new_draw_info (NDI_BLACK, 0, hitter, buf);
		670	}
591	} else if(get_owner(hitter)!=NULL&&hitter->owner->type==PLAYER) {	671	else if (get_owner (hitter) != NULL && hitter->owner->type == PLAYER)
		672	{
592	/* look for stacked spells and start reducing the message chances */	673	/* look for stacked spells and start reducing the message chances */
593	if (hitter->type == SPELL_EFFECT &&	674	if (hitter->type == SPELL_EFFECT && (hitter->subtype == SP_EXPLOSION || hitter->subtype == SP_BULLET || hitter->subtype == SP_CONE))
594	(hitter->subtype == SP_EXPLOSION ||	675	{
595	hitter->subtype == SP_BULLET ||
596	hitter->subtype == SP_CONE)) {
597	i=4;	676	i = 4;
598	map = hitter->map;	677	map = hitter->map;
599	if (out_of_map(map, hitter->x, hitter->y))	678	if (out_of_map (map, hitter->x, hitter->y))
600	return;
601	next = get_map_ob(map, hitter->x, hitter->y);
602	if (next)
603	while(next) {
604	if (next->type == SPELL_EFFECT &&
605	(next->subtype == SP_EXPLOSION || next->subtype==SP_BULLET ||
606	next->subtype == SP_CONE))
607	i*=3;
608	tmp = next;
609	next = tmp->above;
610	}
611	if (i < 0)
612	return;
613	if (rndm(0, i) != 0)
614	return;
615	} else if (rndm(0, 5) != 0)
616	return;	679	return;
		680	next = get_map_ob (map, hitter->x, hitter->y);
		681	if (next)
		682	while (next)
		683	{
		684	if (next->type == SPELL_EFFECT && (next->subtype == SP_EXPLOSION || next->subtype == SP_BULLET || next->subtype == SP_CONE))
		685	i *= 3;
		686	tmp = next;
		687	next = tmp->above;
		688	}
		689	if (i < 0)
		690	return;
		691	if (rndm (0, i) != 0)
		692	return;
		693	}
		694	else if (rndm (0, 5) != 0)
		695	return;
617	sprintf(buf,"Your %s%s %s.", &hitter->name, buf2, &op->name);	696	sprintf (buf, "Your %s%s %s.", &hitter->name, buf2, &op->name);
618	play_sound_map(op->map, op->x, op->y, SOUND_PLAYER_HITS4);	697	play_sound_map (op->map, op->x, op->y, SOUND_PLAYER_HITS4);
619	new_draw_info(NDI_BLACK, 0, hitter->owner, buf);	698	new_draw_info (NDI_BLACK, 0, hitter->owner, buf);
620	}	699	}
621	}	700	}
622		701
623		702
		703	static int
624	static int get_attack_mode (object **target, object **hitter,	704	get_attack_mode (object **target, object **hitter, int *simple_attack)
625	int *simple_attack)
626	{	705	{
627	if (QUERY_FLAG (*target, FLAG_FREED) || QUERY_FLAG (*hitter, FLAG_FREED)) {	706	if (QUERY_FLAG (*target, FLAG_FREED) || QUERY_FLAG (*hitter, FLAG_FREED))
		707	{
628	LOG (llevError, "BUG: get_attack_mode(): freed object\n");	708	LOG (llevError, "BUG: get_attack_mode(): freed object\n");
629	return 1;	709	return 1;
630	}	710	}
631	if ((*target)->head)	711	if ((*target)->head)
632	*target = (*target)->head;	712	*target = (*target)->head;
633	if ((*hitter)->head)	713	if ((*hitter)->head)
634	*hitter = (*hitter)->head;	714	*hitter = (*hitter)->head;
635	if ((*hitter)->env != NULL || (*target)->env != NULL) {	715	if ((*hitter)->env != NULL || (*target)->env != NULL)
		716	{
636	*simple_attack = 1;	717	*simple_attack = 1;
637	return 0;	718	return 0;
638	}	719	}
639	if (QUERY_FLAG (*target, FLAG_REMOVED)	720	if (QUERY_FLAG (*target, FLAG_REMOVED)
640	|| QUERY_FLAG (*hitter, FLAG_REMOVED)
641	|| (*hitter)->map == NULL || !on_same_map((*hitter), (*target)))	721	|| QUERY_FLAG (*hitter, FLAG_REMOVED) || (*hitter)->map == NULL || !on_same_map ((*hitter), (*target)))
642	{	722	{
643	LOG (llevError, "BUG: hitter (arch %s, name %s) with no relation to "	723	LOG (llevError, "BUG: hitter (arch %s, name %s) with no relation to " "target\n", &(*hitter)->arch->name, &(*hitter)->name);
644	"target\n", &(*hitter)->arch->name, &(*hitter)->name);
645	return 1;	724	return 1;
646	}	725	}
647	*simple_attack = 0;	726	*simple_attack = 0;
648	return 0;	727	return 0;
649	}	728	}
650		729
		730	static int
651	static int abort_attack (object *target, object *hitter, int simple_attack)	731	abort_attack (object *target, object *hitter, int simple_attack)
652	{	732	{
		733
653	/* Check if target and hitter are still in a relation similar to the one	734	/* Check if target and hitter are still in a relation similar to the one
654	* determined by get_attack_mode(). Returns true if the relation has changed.	735	* determined by get_attack_mode(). Returns true if the relation has changed.
655	*/	736	*/
656	int new_mode;	737	int new_mode;
657		738
658	if (hitter->env == target || target->env == hitter)	739	if (hitter->env == target || target->env == hitter)
659	new_mode = 1;	740	new_mode = 1;
660	else if (QUERY_FLAG (hitter, FLAG_REMOVED)	741	else if (QUERY_FLAG (hitter, FLAG_REMOVED) || QUERY_FLAG (target, FLAG_REMOVED) || hitter->map == NULL || !on_same_map (hitter, target))
661	|| QUERY_FLAG (target, FLAG_REMOVED)
662	|| hitter->map == NULL || !on_same_map(hitter, target))
663	return 1;	742	return 1;
664	else	743	else
665	new_mode = 0;	744	new_mode = 0;
666	return new_mode != simple_attack;	745	return new_mode != simple_attack;
667	}	746	}
668		747
669	static void thrown_item_effect (object *, object *);	748	static void thrown_item_effect (object *, object *);
670		749
		750	static int
671	static int attack_ob_simple (object *op, object *hitter, int base_dam,	751	attack_ob_simple (object *op, object *hitter, int base_dam, int base_wc)
672	int base_wc)
673	{	752	{
674	int simple_attack, roll, dam=0;	753	int simple_attack, roll, dam = 0;
675	uint32 type;	754	uint32 type;
676	shstr op_name;	755	shstr op_name;
677	tag_t op_tag, hitter_tag;	756	tag_t op_tag, hitter_tag;
678		757
679	if (get_attack_mode (&op, &hitter, &simple_attack))	758	if (get_attack_mode (&op, &hitter, &simple_attack))
		759	goto error;
		760
		761	if (hitter->current_weapon)
		762	if (INVOKE_OBJECT (WEAPON_ATTACK, hitter->current_weapon, ARG_OBJECT (hitter), ARG_OBJECT (op)))
		763	return RESULT_INT (0);
		764
		765	if (INVOKE_OBJECT (ATTACK, op, ARG_OBJECT (hitter)))
		766	return RESULT_INT (0);
		767
		768	op_tag = op->count;
		769	hitter_tag = hitter->count;
		770
		771	/*
		772	* A little check to make it more difficult to dance forward and back
		773	* to avoid ever being hit by monsters.
		774	*/
		775	if (!simple_attack && QUERY_FLAG (op, FLAG_MONSTER) && op->speed_left > -(FABS (op->speed)) * 0.3)
		776	{
		777	/* Decrease speed BEFORE calling process_object. Otherwise, an
		778	* infinite loop occurs, with process_object calling move_monster,
		779	* which then gets here again. By decreasing the speed before
		780	* we call process_object, the 'if' statement above will fail.
		781	*/
		782	op->speed_left--;
		783	process_object (op);
		784	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))
680	goto error;	785	goto error;
681
682	if (hitter->current_weapon)
683	if (INVOKE_OBJECT (WEAPON_ATTACK, hitter->current_weapon, ARG_OBJECT (hitter), ARG_OBJECT (op)))
684	return RESULT_INT (0);
685
686	if (INVOKE_OBJECT (ATTACK, op, ARG_OBJECT (hitter)))
687	return RESULT_INT (0);
688
689	op_tag = op->count;
690	hitter_tag = hitter->count;
691
692	/*
693	* A little check to make it more difficult to dance forward and back
694	* to avoid ever being hit by monsters.
695	*/
696	if ( ! simple_attack && QUERY_FLAG (op, FLAG_MONSTER)
697	&& op->speed_left > -(FABS(op->speed))*0.3)
698	{	786	}
699	/* Decrease speed BEFORE calling process_object. Otherwise, an
700	* infinite loop occurs, with process_object calling move_monster,
701	* which then gets here again. By decreasing the speed before
702	* we call process_object, the 'if' statement above will fail.
703	*/
704	op->speed_left--;
705	process_object(op);
706	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag)
707	|| abort_attack (op, hitter, simple_attack))
708	goto error;
709	}
710		787
711	op_name = op->name;	788	op_name = op->name;
712		789
713	roll=random_roll(1, 20, hitter, PREFER_HIGH);	790	roll = random_roll (1, 20, hitter, PREFER_HIGH);
714		791
715	/* Adjust roll for various situations. */	792	/* Adjust roll for various situations. */
716	if ( ! simple_attack)	793	if (!simple_attack)
717	roll += adj_attackroll(hitter,op);	794	roll += adj_attackroll (hitter, op);
718		795
719	/* See if we hit the creature */	796	/* See if we hit the creature */
720	if(roll==20 || op->stats.ac>=base_wc-roll) {	797	if (roll == 20 || op->stats.ac >= base_wc - roll)
		798	{
721	int hitdam = base_dam;	799	int hitdam = base_dam;
		800
722	if (settings.casting_time == TRUE) {	801	if (settings.casting_time == TRUE)
		802	{
723	if ((hitter->type == PLAYER)&&(hitter->casting_time > -1)){	803	if ((hitter->type == PLAYER) && (hitter->casting_time > -1))
		804	{
724	hitter->casting_time = -1;	805	hitter->casting_time = -1;
725	new_draw_info(NDI_UNIQUE, 0,hitter,"You attacked and lost "	806	new_draw_info (NDI_UNIQUE, 0, hitter, "You attacked and lost " "your spell!");
726	"your spell!");
727	}	807	}
728	if ((op->casting_time > -1)&&(hitdam > 0)){	808	if ((op->casting_time > -1) && (hitdam > 0))
		809	{
729	op->casting_time = -1;	810	op->casting_time = -1;
730	if (op->type == PLAYER) {	811	if (op->type == PLAYER)
		812	{
731	new_draw_info(NDI_UNIQUE, 0,op,"You were hit and lost "	813	new_draw_info (NDI_UNIQUE, 0, op, "You were hit and lost " "your spell!");
732	"your spell!");	814	new_draw_info_format (NDI_ALL | NDI_UNIQUE, 5, NULL, "%s was hit by %s and lost a spell.", &op_name, &hitter->name);
733	new_draw_info_format(NDI_ALL|NDI_UNIQUE,5,NULL,
734	"%s was hit by %s and lost a spell.",
735	&op_name,&hitter->name);
736	}	815	}
737	}	816	}
738	}	817	}
739	if ( ! simple_attack)	818	if (!simple_attack)
740	{	819	{
741	/* If you hit something, the victim should *always* wake up.	820	/* If you hit something, the victim should *always* wake up.
742	* Before, invisible hitters could avoid doing this.	821	* Before, invisible hitters could avoid doing this.
743	* -b.t. */	822	* -b.t. */
744	if (QUERY_FLAG (op, FLAG_SLEEP))	823	if (QUERY_FLAG (op, FLAG_SLEEP))
745	CLEAR_FLAG(op,FLAG_SLEEP);	824	CLEAR_FLAG (op, FLAG_SLEEP);
746		825
747	/* If the victim can't see the attacker, it may alert others	826	/* If the victim can't see the attacker, it may alert others
748	* for help. */	827	* for help. */
749	if (op->type != PLAYER && ! can_see_enemy (op, hitter)	828	if (op->type != PLAYER && !can_see_enemy (op, hitter) && !get_owner (op) && rndm (0, op->stats.Int))
750	&& ! get_owner (op) && rndm(0, op->stats.Int))
751	npc_call_help (op);	829	npc_call_help (op);
752		830
753	/* if you were hidden and hit by a creature, you are discovered*/	831	/* if you were hidden and hit by a creature, you are discovered */
754	if (op->hide && QUERY_FLAG (hitter, FLAG_ALIVE)) {	832	if (op->hide && QUERY_FLAG (hitter, FLAG_ALIVE))
		833	{
755	make_visible (op);	834	make_visible (op);
756	if (op->type == PLAYER)	835	if (op->type == PLAYER)
757	new_draw_info (NDI_UNIQUE, 0, op,	836	new_draw_info (NDI_UNIQUE, 0, op, "You were hit by a wild attack. " "You are no longer hidden!");
758	"You were hit by a wild attack. "
759	"You are no longer hidden!");
760	}	837	}
761		838
762	/* thrown items (hitter) will have various effects	839	/* thrown items (hitter) will have various effects
763	* when they hit the victim. For things like thrown daggers,	840	* when they hit the victim. For things like thrown daggers,
764	* this sets 'hitter' to the actual dagger, and not the	841	* this sets 'hitter' to the actual dagger, and not the
765	* wrapper object.	842	* wrapper object.
766	*/	843	*/
767	thrown_item_effect (hitter, op);	844	thrown_item_effect (hitter, op);
768	if (was_destroyed (hitter, hitter_tag)	845	if (was_destroyed (hitter, hitter_tag) || was_destroyed (op, op_tag) || abort_attack (op, hitter, simple_attack))
769	|| was_destroyed (op, op_tag)
770	|| abort_attack (op, hitter, simple_attack))
771	goto leave;
772	}
773
774	/* Need to do at least 1 damage, otherwise there is no point
775	* to go further and it will cause FPE's below.
776	*/
777	if (hitdam<=0) hitdam=1;
778
779	type=hitter->attacktype;
780	if(!type) type=AT_PHYSICAL;
781	/* Handle monsters that hit back */
782	if ( ! simple_attack && QUERY_FLAG (op, FLAG_HITBACK)
783	&& QUERY_FLAG (hitter, FLAG_ALIVE))
784	{
785	if (op->attacktype & AT_ACID && hitter->type==PLAYER)
786	new_draw_info(NDI_UNIQUE, 0,hitter,"You are splashed by acid!\n");
787	hit_player(hitter, random_roll(0, (op->stats.dam), hitter,
788	PREFER_LOW),op, op->attacktype, 1);
789	if (was_destroyed (op, op_tag)
790	|| was_destroyed (hitter, hitter_tag)
791	|| abort_attack (op, hitter, simple_attack))
792	goto leave;
793	}
794
795	/* In the new attack code, it should handle multiple attack
796	* types in its area, so remove it from here.
797	*/
798	dam=hit_player(op, random_roll(1, hitdam, hitter, PREFER_HIGH),
799	hitter, type, 1);
800	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag)
801	|| abort_attack (op, hitter, simple_attack))
802	goto leave;	846	goto leave;
803	} /* end of if hitter hit op */	847	}
		848
		849	/* Need to do at least 1 damage, otherwise there is no point
		850	* to go further and it will cause FPE's below.
		851	*/
		852	if (hitdam <= 0)
		853	hitdam = 1;
		854
		855	type = hitter->attacktype;
		856	if (!type)
		857	type = AT_PHYSICAL;
		858	/* Handle monsters that hit back */
		859	if (!simple_attack && QUERY_FLAG (op, FLAG_HITBACK) && QUERY_FLAG (hitter, FLAG_ALIVE))
		860	{
		861	if (op->attacktype & AT_ACID && hitter->type == PLAYER)
		862	new_draw_info (NDI_UNIQUE, 0, hitter, "You are splashed by acid!\n");
		863	hit_player (hitter, random_roll (0, (op->stats.dam), hitter, PREFER_LOW), op, op->attacktype, 1);
		864	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))
		865	goto leave;
		866	}
		867
		868	/* In the new attack code, it should handle multiple attack
		869	* types in its area, so remove it from here.
		870	*/
		871	dam = hit_player (op, random_roll (1, hitdam, hitter, PREFER_HIGH), hitter, type, 1);
		872	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag) || abort_attack (op, hitter, simple_attack))
		873	goto leave;
		874	} /* end of if hitter hit op */
804	/* if we missed, dam=0 */	875	/* if we missed, dam=0 */
805		876
806	/*attack_message(dam, type, op, hitter);*/	877	/*attack_message(dam, type, op, hitter); */
807		878
808	goto leave;	879	goto leave;
809		880
810	error:	881	error:
811	dam = 1;	882	dam = 1;
812		883
813	leave:	884	leave:
814		885
815	return dam;	886	return dam;
816	}	887	}
817		888
		889	int
818	int attack_ob (object *op, object *hitter)	890	attack_ob (object *op, object *hitter)
819	{	891	{
820		892
821	if (hitter->head)	893	if (hitter->head)
822	hitter = hitter->head;	894	hitter = hitter->head;
823	return attack_ob_simple (op, hitter, hitter->stats.dam, hitter->stats.wc);	895	return attack_ob_simple (op, hitter, hitter->stats.dam, hitter->stats.wc);
824	}	896	}
825		897
826	/* op is the arrow, tmp is what is stopping the arrow.	898	/* op is the arrow, tmp is what is stopping the arrow.
827	*	899	*
828	* Returns 1 if op was inserted into tmp's inventory, 0 otherwise.	900	* Returns 1 if op was inserted into tmp's inventory, 0 otherwise.
829	*/	901	*/
		902	static int
830	static int stick_arrow (object *op, object *tmp)	903	stick_arrow (object *op, object *tmp)
831	{	904	{
832	/* If the missile hit a player, we insert it in their inventory.	905	/* If the missile hit a player, we insert it in their inventory.
833	* However, if the missile is heavy, we don't do so (assume it falls	906	* However, if the missile is heavy, we don't do so (assume it falls
834	* to the ground after a hit). What a good value for this is up to	907	* to the ground after a hit). What a good value for this is up to
835	* debate - 5000 is 5 kg, so arrows, knives, and other light weapons	908	* debate - 5000 is 5 kg, so arrows, knives, and other light weapons
836	* stick around.	909	* stick around.
837	*/	910	*/
838	if (op->weight <= 5000 && tmp->stats.hp >= 0) {	911	if (op->weight <= 5000 && tmp->stats.hp >= 0)
		912	{
839	if(tmp->head != NULL)	913	if (tmp->head != NULL)
840	tmp = tmp->head;	914	tmp = tmp->head;
		915
841	remove_ob (op);	916	remove_ob (op);
842	op = insert_ob_in_ob(op,tmp);	917	op = insert_ob_in_ob (op, tmp);
		918
843	if (tmp->type== PLAYER)	919	if (tmp->type == PLAYER)
844	esrv_send_item (tmp, op);	920	esrv_send_item (tmp, op);
		921
845	return 1;	922	return 1;
		923	}
846	} else	924	else
847	return 0;	925	return 0;
848	}	926	}
849		927
850	/* hit_with_arrow() disassembles the missile, attacks the victim and	928	/* hit_with_arrow() disassembles the missile, attacks the victim and
851	* reassembles the missile.	929	* reassembles the missile.
852	*	930	*
853	* It returns a pointer to the reassembled missile, or NULL if the missile	931	* It returns a pointer to the reassembled missile, or NULL if the missile
854	* isn't available anymore.	932	* isn't available anymore.
855	*/	933	*/
		934	object *
856	object *hit_with_arrow (object *op, object *victim)	935	hit_with_arrow (object *op, object *victim)
857	{	936	{
858	object *container, *hitter;	937	object *container, *hitter;
859	int hit_something = 0;	938	int hit_something = 0;
860	tag_t victim_tag, hitter_tag;	939	tag_t victim_tag, hitter_tag;
861	sint16 victim_x, victim_y;	940	sint16 victim_x, victim_y;
862		941
863	/* Disassemble missile */	942	/* Disassemble missile */
864	if (op->inv) {	943	if (op->inv)
		944	{
865	container = op;	945	container = op;
866	hitter = op->inv;	946	hitter = op->inv;
867	remove_ob (hitter);	947	remove_ob (hitter);
868	insert_ob_in_map(hitter, container->map,hitter,INS_NO_MERGE | INS_NO_WALK_ON);	948	insert_ob_in_map (hitter, container->map, hitter, INS_NO_MERGE | INS_NO_WALK_ON);
869	/* Note that we now have an empty THROWN_OBJ on the map. Code that	949	/* Note that we now have an empty THROWN_OBJ on the map. Code that
870	* might be called until this THROWN_OBJ is either reassembled or	950	* might be called until this THROWN_OBJ is either reassembled or
871	* removed at the end of this function must be able to deal with empty	951	* removed at the end of this function must be able to deal with empty
872	* THROWN_OBJs. */	952	* THROWN_OBJs. */
873	} else {	953	}
		954	else
		955	{
874	container = NULL;	956	container = NULL;
875	hitter = op;	957	hitter = op;
876	}	958	}
877		959
878	/* Try to hit victim */	960	/* Try to hit victim */
879	victim_x = victim->x;	961	victim_x = victim->x;
880	victim_y = victim->y;	962	victim_y = victim->y;
881	victim_tag = victim->count;	963	victim_tag = victim->count;
882	hitter_tag = hitter->count;	964	hitter_tag = hitter->count;
883		965
884	hit_something = attack_ob_simple (victim, hitter, op->stats.dam, op->stats.wc);	966	hit_something = attack_ob_simple (victim, hitter, op->stats.dam, op->stats.wc);
885		967
886	/* Arrow attacks door, rune of summoning is triggered, demon is put on	968	/* Arrow attacks door, rune of summoning is triggered, demon is put on
887	* arrow, move_apply() calls this function, arrow sticks in demon,	969	* arrow, move_apply() calls this function, arrow sticks in demon,
888	* attack_ob_simple() returns, and we've got an arrow that still exists	970	* attack_ob_simple() returns, and we've got an arrow that still exists
889	* but is no longer on the map. Ugh. (Beware: Such things can happen at	971	* but is no longer on the map. Ugh. (Beware: Such things can happen at
890	* other places as well!)	972	* other places as well!)
891	*/	973	*/
892	if (was_destroyed (hitter, hitter_tag) || hitter->env != NULL) {	974	if (was_destroyed (hitter, hitter_tag) || hitter->env != NULL)
		975	{
893	if (container) {	976	if (container)
		977	{
894	remove_ob (container);	978	remove_ob (container);
895	free_object (container);	979	free_object (container);
		980	}
		981	return NULL;
		982	}
		983
		984	/* Missile hit victim */
		985	/* if the speed is > 10, then this is a fast moving arrow, we go straight
		986	* through the target
		987	*/
		988	if (hit_something && op->speed <= 10.0)
		989	{
		990	/* Stop arrow */
		991	if (container == NULL)
896	}	992	{
		993	hitter = fix_stopped_arrow (hitter);
		994	if (hitter == NULL)
		995	return NULL;
		996	}
		997	else
		998	{
		999	remove_ob (container);
		1000	free_object (container);
		1001	}
		1002
		1003	/* Try to stick arrow into victim */
		1004	if (!was_destroyed (victim, victim_tag) && stick_arrow (hitter, victim))
897	return NULL;	1005	return NULL;
898	}
899		1006
900	/* Missile hit victim */
901	/* if the speed is > 10, then this is a fast moving arrow, we go straight
902	* through the target
903	*/
904	if (hit_something && op->speed <= 10.0)
905	{
906	/* Stop arrow */
907	if (container == NULL) {
908	hitter = fix_stopped_arrow (hitter);
909	if (hitter == NULL)
910	return NULL;
911	} else {
912	remove_ob (container);
913	free_object (container);
914	}
915
916	/* Try to stick arrow into victim */
917	if ( ! was_destroyed (victim, victim_tag)
918	&& stick_arrow (hitter, victim))
919	return NULL;
920
921	/* Else try to put arrow on victim's map square	1007	/* Else try to put arrow on victim's map square
922	* remove check for P_WALL here. If the arrow got to this	1008	* remove check for P_WALL here. If the arrow got to this
923	* space, that is good enough - with the new movement code,	1009	* space, that is good enough - with the new movement code,
924	* there is now the potential for lots of spaces where something	1010	* there is now the potential for lots of spaces where something
925	* can fly over but not otherwise move over. What is the correct	1011	* can fly over but not otherwise move over. What is the correct
926	* way to handle those otherwise?	1012	* way to handle those otherwise?
927	*/	1013	*/
928	if (victim_x != hitter->x || victim_y != hitter->y) {	1014	if (victim_x != hitter->x || victim_y != hitter->y)
		1015	{
929	remove_ob (hitter);	1016	remove_ob (hitter);
930	hitter->x = victim_x;	1017	hitter->x = victim_x;
931	hitter->y = victim_y;	1018	hitter->y = victim_y;
932	insert_ob_in_map (hitter, victim->map, hitter,0);	1019	insert_ob_in_map (hitter, victim->map, hitter, 0);
		1020	}
933	} else {	1021	else
		1022	{
934	/* Else leave arrow where it is */	1023	/* Else leave arrow where it is */
935	merge_ob (hitter, NULL);	1024	merge_ob (hitter, NULL);
936	}	1025	}
937	return NULL;	1026	return NULL;
938	}	1027	}
939		1028
940	if (hit_something && op->speed >= 10.0)	1029	if (hit_something && op->speed >= 10.0)
941	op->speed -= 1.0;	1030	op->speed -= 1.0;
942		1031
943	/* Missile missed victim - reassemble missile */	1032	/* Missile missed victim - reassemble missile */
944	if (container) {	1033	if (container)
		1034	{
945	remove_ob (hitter);	1035	remove_ob (hitter);
946	insert_ob_in_ob (hitter, container);	1036	insert_ob_in_ob (hitter, container);
947	}	1037	}
948	return op;	1038	return op;
949	}	1039	}
950		1040
951		1041
		1042	void
952	void tear_down_wall(object *op)	1043	tear_down_wall (object *op)
953	{	1044	{
954	int perc=0;	1045	int perc = 0;
955		1046
956	if (!op->stats.maxhp) {	1047	if (!op->stats.maxhp)
		1048	{
957	LOG(llevError, "TEAR_DOWN wall %s had no maxhp.\n", &op->name);	1049	LOG (llevError, "TEAR_DOWN wall %s had no maxhp.\n", &op->name);
958	perc = 1;	1050	perc = 1;
		1051	}
959	} else if(!GET_ANIM_ID(op)) {	1052	else if (!GET_ANIM_ID (op))
		1053	{
960	/* Object has been called - no animations, so remove it */	1054	/* Object has been called - no animations, so remove it */
961	if(op->stats.hp<0) {	1055	if (op->stats.hp < 0)
		1056	{
962	remove_ob(op); /* Should update LOS */	1057	remove_ob (op); /* Should update LOS */
963	free_object(op);	1058	free_object (op);
964	/* Don't know why this is here - remove_ob should do it for us */	1059	/* Don't know why this is here - remove_ob should do it for us */
965	/*update_position(m, x, y);*/	1060	/*update_position(m, x, y); */
966	}	1061	}
967	return; /* no animations, so nothing more to do */	1062	return; /* no animations, so nothing more to do */
968	}	1063	}
969	perc = NUM_ANIMATIONS(op)	1064	perc = NUM_ANIMATIONS (op) - ((int) NUM_ANIMATIONS (op) * op->stats.hp) / op->stats.maxhp;
970	- ((int)NUM_ANIMATIONS(op)*op->stats.hp)/op->stats.maxhp;
971	if (perc >= (int) NUM_ANIMATIONS(op))	1065	if (perc >= (int) NUM_ANIMATIONS (op))
972	perc = NUM_ANIMATIONS(op)-1;	1066	perc = NUM_ANIMATIONS (op) - 1;
973	else if (perc < 1)	1067	else if (perc < 1)
974	perc = 1;	1068	perc = 1;
975	SET_ANIMATION(op, perc);	1069	SET_ANIMATION (op, perc);
976	update_object(op,UP_OBJ_FACE);	1070	update_object (op, UP_OBJ_FACE);
977	if(perc==NUM_ANIMATIONS(op)-1) { /* Reached the last animation */	1071	if (perc == NUM_ANIMATIONS (op) - 1)
		1072	{ /* Reached the last animation */
978	if(op->face==blank_face) {	1073	if (op->face == blank_face)
		1074	{
979	/* If the last face is blank, remove the ob */	1075	/* If the last face is blank, remove the ob */
980	remove_ob(op); /* Should update LOS */	1076	remove_ob (op); /* Should update LOS */
981	free_object(op);	1077	free_object (op);
982		1078
983	/* remove_ob should call update_position for us */	1079	/* remove_ob should call update_position for us */
984	/*update_position(m, x, y);*/	1080	/*update_position(m, x, y); */
985		1081
		1082	}
		1083	else
986	} else { /* The last face was not blank, leave an image */	1084	{ /* The last face was not blank, leave an image */
987	CLEAR_FLAG(op, FLAG_BLOCKSVIEW);	1085	CLEAR_FLAG (op, FLAG_BLOCKSVIEW);
988	update_all_los(op->map, op->x, op->y);	1086	update_all_los (op->map, op->x, op->y);
989	op->move_block = 0;	1087	op->move_block = 0;
990	CLEAR_FLAG(op, FLAG_ALIVE);	1088	CLEAR_FLAG (op, FLAG_ALIVE);
991	}	1089	}
992	}	1090	}
993	}	1091	}
994		1092
		1093	void
995	void scare_creature(object *target, object *hitter)	1094	scare_creature (object *target, object *hitter)
996	{	1095	{
997	object *owner = get_owner(hitter);	1096	object *owner = get_owner (hitter);
998		1097
999	if (!owner) owner=hitter;	1098	if (!owner)
		1099	owner = hitter;
1000		1100
1001	SET_FLAG(target, FLAG_SCARED);	1101	SET_FLAG (target, FLAG_SCARED);
1002	if (!target->enemy) target->enemy=owner;	1102	if (!target->enemy)
		1103	target->enemy = owner;
1003	}	1104	}
1004		1105
1005		1106
1006	/* This returns the amount of damage hitter does to op with the	1107	/* This returns the amount of damage hitter does to op with the
1007	* appropriate attacktype. Only 1 attacktype should be set at a time.	1108	* appropriate attacktype. Only 1 attacktype should be set at a time.
1008	* This doesn't damage the player, but returns how much it should	1109	* This doesn't damage the player, but returns how much it should
1009	* take. However, it will do other effects (paralyzation, slow, etc.)	1110	* take. However, it will do other effects (paralyzation, slow, etc.)
1010	* Note - changed for PR code - we now pass the attack number and not	1111	* Note - changed for PR code - we now pass the attack number and not
1011	* the attacktype. Makes it easier for the PR code. */	1112	* the attacktype. Makes it easier for the PR code. */
1012		1113
		1114	int
1013	int hit_player_attacktype(object *op, object *hitter, int dam,	1115	hit_player_attacktype (object *op, object *hitter, int dam, uint32 attacknum, int magic)
1014	uint32 attacknum, int magic) {	1116	{
1015		1117
1016	int doesnt_slay = 1;	1118	int doesnt_slay = 1;
1017		1119
1018	/* Catch anyone that may be trying to send us a bitmask instead of the number */	1120	/* Catch anyone that may be trying to send us a bitmask instead of the number */
1019	if (attacknum >= NROFATTACKS) {	1121	if (attacknum >= NROFATTACKS)
		1122	{
1020	LOG(llevError, "hit_player_attacktype: Invalid attacknumber passed: %u\n", attacknum);	1123	LOG (llevError, "hit_player_attacktype: Invalid attacknumber passed: %u\n", attacknum);
1021	return 0;	1124	return 0;
1022	}
1023		1125	}
		1126
1024	if (dam < 0) {	1127	if (dam < 0)
		1128	{
1025	LOG(llevError,"hit_player_attacktype called with negative damage: %d\n", dam);	1129	LOG (llevError, "hit_player_attacktype called with negative damage: %d\n", dam);
1026	return 0;	1130	return 0;
1027	}
1028		1131	}
		1132
1029	/* AT_INTERNAL is supposed to do exactly dam. Put a case here so	1133	/* AT_INTERNAL is supposed to do exactly dam. Put a case here so
1030	* people can't mess with that or it otherwise get confused. */	1134	* people can't mess with that or it otherwise get confused. */
1031	if (attacknum == ATNR_INTERNAL) return dam;	1135	if (attacknum == ATNR_INTERNAL)
1032		1136	return dam;
		1137
1033	if (hitter->slaying) {	1138	if (hitter->slaying)
		1139	{
1034	if(((op->race != NULL) && strstr(hitter->slaying, op->race)) ||	1140	if (((op->race != NULL) && strstr (hitter->slaying, op->race)) ||
1035	(op->arch && (op->arch->name != NULL) &&	1141	(op->arch && (op->arch->name != NULL) && strstr (op->arch->name, hitter->slaying)))
1036	strstr(op->arch->name, hitter->slaying))
1037	){	1142	{
1038	doesnt_slay = 0;	1143	doesnt_slay = 0;
1039	dam *= 3;	1144	dam *= 3;
1040	}	1145	}
1041	}	1146	}
1042		1147
1043	/* Adjust the damage for resistance. Note that neg. values increase damage. */	1148	/* Adjust the damage for resistance. Note that neg. values increase damage. */
1044	if (op->resist[attacknum]) {	1149	if (op->resist[attacknum])
		1150	{
1045	/* basically: dam = dam*(100-op->resist[attacknum])/100;	1151	/* basically: dam = dam*(100-op->resist[attacknum])/100;
1046	* in case 0>dam>1, we try to "simulate" a float value-effect */	1152	* in case 0>dam>1, we try to "simulate" a float value-effect */
1047	dam *= (100-op->resist[attacknum]);	1153	dam *= (100 - op->resist[attacknum]);
1048	if (dam >= 100) dam /= 100;	1154	if (dam >= 100)
		1155	dam /= 100;
1049	else	1156	else
1050	dam = (dam > (random_roll(0, 99, op, PREFER_LOW))) ? 1 : 0;	1157	dam = (dam > (random_roll (0, 99, op, PREFER_LOW))) ? 1 : 0;
1051	}	1158	}
1052		1159
1053	/* Special hack. By default, if immune to something, you	1160	/* Special hack. By default, if immune to something, you
1054	* shouldn't need to worry. However, acid is an exception, since	1161	* shouldn't need to worry. However, acid is an exception, since
1055	* it can still damage your items. Only include attacktypes if	1162	* it can still damage your items. Only include attacktypes if
1056	* special processing is needed */	1163	* special processing is needed */
1057		1164
1058	if ((op->resist[attacknum] >= 100) &&	1165	if ((op->resist[attacknum] >= 100) && doesnt_slay && (attacknum != ATNR_ACID))
1059	doesnt_slay && (attacknum != ATNR_ACID))
1060	return 0;	1166	return 0;
1061		1167
1062	/* Keep this in order - makes things easier to find */	1168	/* Keep this in order - makes things easier to find */
		1169
		1170	switch (attacknum)
1063		1171	{
1064	switch(attacknum) {
1065	case ATNR_PHYSICAL:	1172	case ATNR_PHYSICAL:
1066	/* here also check for diseases */	1173	/* here also check for diseases */
1067	check_physically_infect(op, hitter);	1174	check_physically_infect (op, hitter);
1068	break;	1175	break;
1069		1176
1070	/* Don't need to do anything for:	1177	/* Don't need to do anything for:
1071	magic,	1178	magic,
1072	fire,	1179	fire,
1073	electricity,	1180	electricity,
1074	cold */	1181	cold */
1075		1182
1076	case ATNR_CONFUSION:	1183	case ATNR_CONFUSION:
1077	case ATNR_POISON:	1184	case ATNR_POISON:
1078	case ATNR_SLOW:	1185	case ATNR_SLOW:
1079	case ATNR_PARALYZE:	1186	case ATNR_PARALYZE:
1080	case ATNR_FEAR:	1187	case ATNR_FEAR:
1081	case ATNR_CANCELLATION:	1188	case ATNR_CANCELLATION:
1082	case ATNR_DEPLETE:	1189	case ATNR_DEPLETE:
1083	case ATNR_BLIND:	1190	case ATNR_BLIND:
1084	{	1191	{
1085	/* chance for inflicting a special attack depends on the	1192	/* chance for inflicting a special attack depends on the
1086	* difference between attacker's and defender's level	1193	* difference between attacker's and defender's level
1087	*/	1194	*/
1088	int level_diff = MIN(110, MAX(0, op->level - hitter->level));	1195	int level_diff = MIN (110, MAX (0, op->level - hitter->level));
1089		1196
1090	/* First, only creatures/players with speed can be affected.	1197	/* First, only creatures/players with speed can be affected.
1091	* Second, just getting hit doesn't mean it always affects	1198	* Second, just getting hit doesn't mean it always affects
1092	* you. Third, you still get a saving through against the	1199	* you. Third, you still get a saving through against the
1093	* effect.	1200	* effect.
1094	*/	1201	*/
1095	if (op->speed &&	1202	if (op->speed &&
1096	(QUERY_FLAG(op, FLAG_MONSTER) || op->type==PLAYER) &&	1203	(QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) &&
1097	!(rndm(0, (attacknum == ATNR_SLOW?6:3)-1)) &&	1204	!(rndm (0, (attacknum == ATNR_SLOW ? 6 : 3) - 1)) && !did_make_save (op, level_diff, op->resist[attacknum] / 10))
1098	!did_make_save(op, level_diff, op->resist[attacknum]/10)) {	1205	{
1099		1206
1100	/* Player has been hit by something */	1207	/* Player has been hit by something */
1101	if (attacknum == ATNR_CONFUSION) confuse_player(op,hitter,dam);	1208	if (attacknum == ATNR_CONFUSION)
		1209	confuse_player (op, hitter, dam);
1102	else if (attacknum == ATNR_POISON) poison_player(op,hitter,dam);	1210	else if (attacknum == ATNR_POISON)
		1211	poison_player (op, hitter, dam);
1103	else if (attacknum == ATNR_SLOW) slow_player(op,hitter,dam);	1212	else if (attacknum == ATNR_SLOW)
		1213	slow_player (op, hitter, dam);
1104	else if (attacknum == ATNR_PARALYZE) paralyze_player(op,hitter,dam);	1214	else if (attacknum == ATNR_PARALYZE)
		1215	paralyze_player (op, hitter, dam);
1105	else if (attacknum == ATNR_FEAR) scare_creature(op, hitter);	1216	else if (attacknum == ATNR_FEAR)
		1217	scare_creature (op, hitter);
1106	else if (attacknum == ATNR_CANCELLATION) cancellation(op);	1218	else if (attacknum == ATNR_CANCELLATION)
		1219	cancellation (op);
1107	else if (attacknum == ATNR_DEPLETE) drain_stat(op);	1220	else if (attacknum == ATNR_DEPLETE)
		1221	drain_stat (op);
1108	else if (attacknum == ATNR_BLIND && !QUERY_FLAG(op,FLAG_UNDEAD) &&	1222	else if (attacknum == ATNR_BLIND && !QUERY_FLAG (op, FLAG_UNDEAD) && !QUERY_FLAG (op, FLAG_GENERATOR))
1109	!QUERY_FLAG(op,FLAG_GENERATOR)) blind_player(op,hitter,dam);	1223	blind_player (op, hitter, dam);
1110	}	1224	}
1111	dam = 0; /* These are all effects and don't do real damage */	1225	dam = 0; /* These are all effects and don't do real damage */
1112	}	1226	}
1113	break;	1227	break;
1114	case ATNR_ACID:	1228	case ATNR_ACID:
1115	{
1116	int flag=0;
1117
1118	/* Items only get corroded if you're not on a battleground and
1119	* if your acid resistance is below 50%. */
1120	if (!op_on_battleground(op, NULL, NULL) &&
1121	(op->resist[ATNR_ACID] < 50))
1122	{	1229	{
		1230	int flag = 0;
		1231
		1232	/* Items only get corroded if you're not on a battleground and
		1233	* if your acid resistance is below 50%. */
		1234	if (!op_on_battleground (op, NULL, NULL) && (op->resist[ATNR_ACID] < 50))
		1235	{
1123	object *tmp;	1236	object *tmp;
		1237
1124	for(tmp=op->inv; tmp!=NULL; tmp=tmp->below) {	1238	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
		1239	{
1125	if(tmp->invisible)	1240	if (tmp->invisible)
1126	continue;	1241	continue;
1127	if(!QUERY_FLAG(tmp, FLAG_APPLIED) ||	1242	if (!QUERY_FLAG (tmp, FLAG_APPLIED) || (tmp->resist[ATNR_ACID] >= 10))
1128	(tmp->resist[ATNR_ACID] >= 10))
1129	/* >= 10% acid res. on itmes will protect these */	1243	/* >= 10% acid res. on itmes will protect these */
1130	continue;	1244	continue;
1131	if(!(tmp->material & M_IRON))	1245	if (!(tmp->material & M_IRON))
1132	continue;	1246	continue;
1133	if(tmp->magic < -4) /* Let's stop at -5 */	1247	if (tmp->magic < -4) /* Let's stop at -5 */
1134	continue;	1248	continue;
1135	if(tmp->type==RING ||	1249	if (tmp->type == RING ||
1136	/* removed boots and gloves from exclusion list in	1250	/* removed boots and gloves from exclusion list in
1137	PR */	1251	PR */
1138	tmp->type==GIRDLE ||	1252	tmp->type == GIRDLE || tmp->type == AMULET || tmp->type == WAND || tmp->type == ROD || tmp->type == HORN)
1139	tmp->type==AMULET ||
1140	tmp->type==WAND ||
1141	tmp->type==ROD ||
1142	tmp->type==HORN)
1143	continue; /* To avoid some strange effects */	1253	continue; /* To avoid some strange effects */
1144		1254
1145	/* High damage acid has better chance of corroding	1255	/* High damage acid has better chance of corroding
1146	objects */	1256	objects */
1147	if(rndm(0, dam+4) >
1148	random_roll(0, 39, op, PREFER_HIGH)+2*tmp->magic) {	1257	if (rndm (0, dam + 4) > random_roll (0, 39, op, PREFER_HIGH) + 2 * tmp->magic)
		1258	{
1149	if(op->type == PLAYER)	1259	if (op->type == PLAYER)
1150	/* Make this more visible */	1260	/* Make this more visible */
1151	new_draw_info_format(NDI_UNIQUE|NDI_RED,0, op,	1261	new_draw_info_format (NDI_UNIQUE | NDI_RED, 0, op,
1152	"The %s's acid corrodes your %s!",	1262	"The %s's acid corrodes your %s!", query_name (hitter), query_name (tmp));
1153	query_name(hitter), query_name(tmp));
1154	flag = 1;	1263	flag = 1;
1155	tmp->magic--;	1264	tmp->magic--;
1156	if(op->type == PLAYER)	1265	if (op->type == PLAYER)
1157	esrv_send_item(op, tmp);	1266	esrv_send_item (op, tmp);
		1267	}
1158	}	1268	}
		1269	if (flag)
		1270	fix_player (op); /* Something was corroded */
1159	}	1271	}
1160	if(flag)
1161	fix_player(op); /* Something was corroded */
1162	}	1272	}
1163	}
1164	break;	1273	break;
1165	case ATNR_DRAIN:	1274	case ATNR_DRAIN:
1166	{	1275	{
1167	/* rate is the proportion of exp drained. High rate means	1276	/* rate is the proportion of exp drained. High rate means
1168	* not much is drained, low rate means a lot is drained.	1277	* not much is drained, low rate means a lot is drained.
1169	*/
1170	int rate;
1171
1172	if(op->resist[ATNR_DRAIN] >= 0)
1173	rate = 400 + op->resist[ATNR_DRAIN] * 3;
1174	else
1175	rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]);
1176
1177	if(op->stats.exp <= rate) {
1178	if(op->type == GOLEM)
1179	dam = 999; /* Its force is "sucked" away. 8) */
1180	else
1181	/* If we can't drain, lets try to do physical damage */
1182	dam = hit_player_attacktype(op, hitter, dam, ATNR_PHYSICAL, magic);
1183	} else {
1184	/* Randomly give the hitter some hp */
1185	if(hitter->stats.hp<hitter->stats.maxhp &&
1186	(op->level > hitter->level) &&
1187	random_roll(0, (op->level-hitter->level+2), hitter, PREFER_HIGH)>3)
1188	hitter->stats.hp++;
1189
1190	/* Can't do drains on battleground spaces.
1191	* Move the wiz check up here - before, the hitter wouldn't gain exp
1192	* exp, but the wiz would still lose exp! If drainee is a wiz,
1193	* nothing happens.
1194	* Try to credit the owner. We try to display player -> player drain
1195	* attacks, hence all the != PLAYER checks.
1196	*/	1278	*/
		1279	int rate;
		1280
		1281	if (op->resist[ATNR_DRAIN] >= 0)
		1282	rate = 400 + op->resist[ATNR_DRAIN] * 3;
		1283	else
		1284	rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]);
		1285
		1286	if (op->stats.exp <= rate)
		1287	{
		1288	if (op->type == GOLEM)
		1289	dam = 999; /* Its force is "sucked" away. 8) */
		1290	else
		1291	/* If we can't drain, lets try to do physical damage */
		1292	dam = hit_player_attacktype (op, hitter, dam, ATNR_PHYSICAL, magic);
		1293	}
		1294	else
		1295	{
		1296	/* Randomly give the hitter some hp */
		1297	if (hitter->stats.hp < hitter->stats.maxhp &&
		1298	(op->level > hitter->level) && random_roll (0, (op->level - hitter->level + 2), hitter, PREFER_HIGH) > 3)
		1299	hitter->stats.hp++;
		1300
		1301	/* Can't do drains on battleground spaces.
		1302	* Move the wiz check up here - before, the hitter wouldn't gain exp
		1303	* exp, but the wiz would still lose exp! If drainee is a wiz,
		1304	* nothing happens.
		1305	* Try to credit the owner. We try to display player -> player drain
		1306	* attacks, hence all the != PLAYER checks.
		1307	*/
1197	if (!op_on_battleground(hitter, NULL, NULL) && !QUERY_FLAG(op,FLAG_WAS_WIZ)) {	1308	if (!op_on_battleground (hitter, NULL, NULL) && !QUERY_FLAG (op, FLAG_WAS_WIZ))
		1309	{
1198	object *owner = get_owner(hitter);	1310	object *owner = get_owner (hitter);
1199		1311
1200	if (owner && owner != hitter) {	1312	if (owner && owner != hitter)
		1313	{
1201	if (op->type != PLAYER || owner->type != PLAYER)	1314	if (op->type != PLAYER || owner->type != PLAYER)
1202	change_exp(owner, op->stats.exp/(rate*2),	1315	change_exp (owner, op->stats.exp / (rate * 2),
1203	hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *)0, SK_EXP_TOTAL);	1316	hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, SK_EXP_TOTAL);
		1317	}
1204	} else if (op->type != PLAYER || hitter->type != PLAYER) {	1318	else if (op->type != PLAYER || hitter->type != PLAYER)
		1319	{
1205	change_exp(hitter, op->stats.exp/(rate*2),	1320	change_exp (hitter, op->stats.exp / (rate * 2),
1206	hitter->chosen_skill ? hitter->chosen_skill->skill : (const char*)0, 0);	1321	hitter->chosen_skill ? hitter->chosen_skill->skill : (const char *) 0, 0);
		1322	}
		1323	change_exp (op, -op->stats.exp / rate, NULL, 0);
1207	}	1324	}
1208	change_exp(op,-op->stats.exp/rate, NULL, 0);
1209	}
1210	dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure	1325	dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure
1211	* drain attack, you won't know that you are actually sucking out EXP,	1326	* drain attack, you won't know that you are actually sucking out EXP,
1212	* as the messages will say you missed	1327	* as the messages will say you missed
1213	*/	1328	*/
		1329	}
1214	}	1330	}
1215	}
1216	break;	1331	break;
1217	case ATNR_TURN_UNDEAD:	1332	case ATNR_TURN_UNDEAD:
1218	{	1333	{
1219	if (QUERY_FLAG(op,FLAG_UNDEAD)) {	1334	if (QUERY_FLAG (op, FLAG_UNDEAD))
		1335	{
		1336	object *owner = get_owner (hitter) == NULL ? hitter : get_owner (hitter);
		1337	object *god = find_god (determine_god (owner));
		1338	int div = 1;
		1339
		1340	/* if undead are not an enemy of your god, you turn them
		1341	* at half strength */
		1342	if (!god || !god->slaying || strstr (god->slaying, undead_name) == NULL)
		1343	div = 2;
		1344	/* Give a bonus if you resist turn undead */
		1345	if (op->level * div < (turn_bonus[owner->stats.Wis] + owner->level + (op->resist[ATNR_TURN_UNDEAD] / 100)))
		1346	scare_creature (op, owner);
		1347	}
		1348	else
		1349	dam = 0; /* don't damage non undead - should we damage
		1350	undead? */
		1351	}
		1352	break;
		1353	case ATNR_DEATH:
		1354	deathstrike_player (op, hitter, &dam);
		1355	break;
		1356	case ATNR_CHAOS:
		1357	LOG (llevError, "%s was hit by %s with non-specific chaos.\n", query_name (op), query_name (hitter));
		1358	dam = 0;
		1359	break;
		1360	case ATNR_COUNTERSPELL:
		1361	LOG (llevError, "%s was hit by %s with counterspell attack.\n", query_name (op), query_name (hitter));
		1362	dam = 0;
		1363	/* This should never happen. Counterspell is handled
		1364	* seperately and filtered out. If this does happen,
		1365	* Counterspell has no effect on anything but spells, so it
		1366	* does no damage. */
		1367	break;
		1368	case ATNR_HOLYWORD:
		1369	{
		1370	/* This has already been handled by hit_player,
		1371	* no need to check twice -- DAMN */
		1372
1220	object *owner = get_owner(hitter) == NULL ? hitter : get_owner(hitter);	1373	object *owner = get_owner (hitter) == NULL ? hitter : get_owner (hitter);
1221	object *god = find_god (determine_god (owner));
1222	int div = 1;
1223		1374
1224	/* if undead are not an enemy of your god, you turn them
1225	* at half strength */
1226	if (! god || ! god->slaying ||
1227	strstr (god->slaying, undead_name) == NULL)
1228	div = 2;
1229	/* Give a bonus if you resist turn undead */
1230	if (op->level * div <
1231	(turn_bonus[owner->stats.Wis]+owner->level +
1232	(op->resist[ATNR_TURN_UNDEAD]/100)))
1233	scare_creature(op, owner);
1234	}
1235	else
1236	dam = 0; /* don't damage non undead - should we damage
1237	undead? */
1238	} break;
1239	case ATNR_DEATH:
1240	deathstrike_player(op, hitter, &dam);
1241	break;
1242	case ATNR_CHAOS:
1243	LOG(llevError,
1244	"%s was hit by %s with non-specific chaos.\n",
1245	query_name(op),
1246	query_name(hitter));
1247	dam = 0;
1248	break;
1249	case ATNR_COUNTERSPELL:
1250	LOG(llevError,
1251	"%s was hit by %s with counterspell attack.\n",
1252	query_name(op),
1253	query_name(hitter));
1254	dam = 0;
1255	/* This should never happen. Counterspell is handled
1256	* seperately and filtered out. If this does happen,
1257	* Counterspell has no effect on anything but spells, so it
1258	* does no damage. */
1259	break;
1260	case ATNR_HOLYWORD:
1261	{
1262	/* This has already been handled by hit_player,
1263	* no need to check twice -- DAMN */
1264
1265	object *owner = get_owner(hitter)==NULL?hitter:get_owner(hitter);
1266
1267	/* As with turn undead above, give a bonus on the saving throw */	1375	/* As with turn undead above, give a bonus on the saving throw */
1268	if((op->level+(op->resist[ATNR_HOLYWORD]/100)) <	1376	if ((op->level + (op->resist[ATNR_HOLYWORD] / 100)) < owner->level + turn_bonus[owner->stats.Wis])
1269	owner->level+turn_bonus[owner->stats.Wis])
1270	scare_creature(op, owner);	1377	scare_creature (op, owner);
		1378	}
1271	} break;	1379	break;
1272	case ATNR_LIFE_STEALING:	1380	case ATNR_LIFE_STEALING:
1273	{	1381	{
1274	int new_hp;	1382	int new_hp;
		1383
1275	/* this is replacement to drain for players, instead of taking	1384	/* this is replacement to drain for players, instead of taking
1276	* exp it takes hp. It is geared for players, probably not	1385	* exp it takes hp. It is geared for players, probably not
1277	* much use giving it to monsters	1386	* much use giving it to monsters
1278	*	1387	*
1279	* life stealing doesn't do a lot of damage, but it gives the	1388	* life stealing doesn't do a lot of damage, but it gives the
1280	* damage it does do to the player. Given that,	1389	* damage it does do to the player. Given that,
1281	* it only does 1/10'th normal damage (hence the divide by	1390	* it only does 1/10'th normal damage (hence the divide by
1282	* 1000).	1391	* 1000).
1283	*/	1392	*/
1284	/* You can't steal life from something undead */	1393	/* You can't steal life from something undead */
1285	if ((op->type == GOLEM) || (QUERY_FLAG(op, FLAG_UNDEAD))) return 0;	1394	if ((op->type == GOLEM) || (QUERY_FLAG (op, FLAG_UNDEAD)))
		1395	return 0;
1286	/* If drain protection is higher than life stealing, use that */	1396	/* If drain protection is higher than life stealing, use that */
1287	if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])	1397	if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])
1288	dam = (dam*(100 - op->resist[ATNR_DRAIN])) / 3000;	1398	dam = (dam * (100 - op->resist[ATNR_DRAIN])) / 3000;
		1399	else
1289	else dam = (dam*(100 - op->resist[ATNR_LIFE_STEALING])) / 3000;	1400	dam = (dam * (100 - op->resist[ATNR_LIFE_STEALING])) / 3000;
1290	/* You die at -1 hp, not zero. */	1401	/* You die at -1 hp, not zero. */
1291	if (dam > (op->stats.hp+1)) dam = op->stats.hp+1;	1402	if (dam > (op->stats.hp + 1))
		1403	dam = op->stats.hp + 1;
1292	new_hp = hitter->stats.hp + dam;	1404	new_hp = hitter->stats.hp + dam;
1293	if (new_hp > hitter->stats.maxhp) new_hp = hitter->stats.maxhp;	1405	if (new_hp > hitter->stats.maxhp)
1294	if (new_hp > hitter->stats.hp) hitter->stats.hp = new_hp;	1406	new_hp = hitter->stats.maxhp;
		1407	if (new_hp > hitter->stats.hp)
		1408	hitter->stats.hp = new_hp;
		1409	}
1295	}	1410	}
1296	}
1297	return dam;	1411	return dam;
1298	}	1412	}
1299		1413
1300		1414
1301	/* GROS: This code comes from hit_player. It has been made external to	1415	/* GROS: This code comes from hit_player. It has been made external to
1302	* allow script procedures to "kill" objects in a combat-like fashion.	1416	* allow script procedures to "kill" objects in a combat-like fashion.
…		…
1311	* This function was a bit of a mess with hitter getting changed,	1425	* This function was a bit of a mess with hitter getting changed,
1312	* values being stored away but not used, etc. I've cleaned it up	1426	* values being stored away but not used, etc. I've cleaned it up
1313	* a bit - I think it should be functionally equivalant.	1427	* a bit - I think it should be functionally equivalant.
1314	* MSW 2002-07-17	1428	* MSW 2002-07-17
1315	*/	1429	*/
		1430	int
1316	int kill_object(object *op,int dam, object *hitter, int type)	1431	kill_object (object *op, int dam, object *hitter, int type)
1317	{	1432	{
1318	char buf[MAX_BUF];	1433	char buf[MAX_BUF];
1319	const char *skill;	1434	const char *skill;
1320	int maxdam=0;	1435	int maxdam = 0;
1321	int battleg=0; /* true if op standing on battleground */	1436	int battleg = 0; /* true if op standing on battleground */
1322	int pk=0; /* true if op and what controls hitter are both players*/	1437	int pk = 0; /* true if op and what controls hitter are both players */
1323	object *owner=NULL;	1438	object *owner = NULL;
1324	object *skop=NULL;	1439	object *skop = NULL;
1325		1440
1326	if (op->stats.hp>=0)	1441	if (op->stats.hp >= 0)
1327	return -1;	1442	return -1;
1328		1443
1329	if (INVOKE_OBJECT (KILL, op, ARG_OBJECT (hitter)))	1444	if (INVOKE_OBJECT (KILL, op, ARG_OBJECT (hitter)))
1330	return 0;	1445	return 0;
1331		1446
1332	/* maxdam needs to be the amount of damage it took to kill	1447	/* maxdam needs to be the amount of damage it took to kill
1333	* this creature. The function(s) that call us have already	1448	* this creature. The function(s) that call us have already
1334	* adjusted the creatures HP total, so that is negative.	1449	* adjusted the creatures HP total, so that is negative.
1335	*/	1450	*/
1336	maxdam = dam + op->stats.hp + 1;	1451	maxdam = dam + op->stats.hp + 1;
1337		1452
1338	if(QUERY_FLAG(op,FLAG_BLOCKSVIEW))	1453	if (QUERY_FLAG (op, FLAG_BLOCKSVIEW))
1339	update_all_los(op->map,op->x, op->y); /* makes sure los will be recalculated */	1454	update_all_los (op->map, op->x, op->y); /* makes sure los will be recalculated */
1340		1455
1341	if(op->type==DOOR) {	1456	if (op->type == DOOR)
		1457	{
1342	op->speed = 0.1;	1458	op->speed = 0.1;
1343	update_ob_speed(op);	1459	update_ob_speed (op);
1344	op->speed_left= -0.05;	1460	op->speed_left = -0.05;
1345	return maxdam;	1461	return maxdam;
1346	}	1462	}
1347	if(QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER) {	1463	if (QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER)
		1464	{
1348	remove_friendly_object(op);	1465	remove_friendly_object (op);
1349	if (get_owner (op) != NULL && op->owner->type == PLAYER &&	1466	if (get_owner (op) != NULL && op->owner->type == PLAYER && op->owner->contr->ranges[range_golem] == op)
1350	op->owner->contr->ranges[range_golem] == op) {	1467	{
1351	op->owner->contr->ranges[range_golem]=NULL;	1468	op->owner->contr->ranges[range_golem] = NULL;
1352	op->owner->contr->golem_count=0;	1469	op->owner->contr->golem_count = 0;
1353	}	1470	}
1354		1471
1355	remove_ob(op);	1472	remove_ob (op);
1356	free_object(op);	1473	free_object (op);
1357	return maxdam;	1474	return maxdam;
1358	}	1475	}
1359		1476
1360	/* Now lets start dealing with experience we get for killing something */	1477	/* Now lets start dealing with experience we get for killing something */
1361		1478
1362	owner=get_owner(hitter);	1479	owner = get_owner (hitter);
1363	if(owner==NULL)	1480	if (owner == NULL)
1364	owner=hitter;	1481	owner = hitter;
1365		1482
1366	/* is the victim (op) standing on battleground? */	1483	/* is the victim (op) standing on battleground? */
1367	if (op_on_battleground(op, NULL, NULL)) battleg=1;	1484	if (op_on_battleground (op, NULL, NULL))
1368		1485	battleg = 1;
		1486
1369	/* is this player killing?*/	1487	/* is this player killing? */
1370	if (op->type == PLAYER && owner->type == PLAYER) pk=1;	1488	if (op->type == PLAYER && owner->type == PLAYER)
		1489	pk = 1;
1371		1490
1372	/* Player killed something */	1491	/* Player killed something */
1373	if(owner->type==PLAYER) {	1492	if (owner->type == PLAYER)
		1493	{
1374	Log_Kill(owner->name,	1494	Log_Kill (owner->name,
1375	query_name(op),op->type,	1495	query_name (op), op->type, (owner != hitter) ? query_name (hitter) : NULL, (owner != hitter) ? hitter->type : 0);
1376	(owner!=hitter) ? query_name(hitter) : NULL,
1377	(owner!=hitter) ? hitter->type : 0);
1378		1496
1379	/* Log players killing other players - makes it easier to detect	1497	/* Log players killing other players - makes it easier to detect
1380	* and filter out malicious player killers - that is why the	1498	* and filter out malicious player killers - that is why the
1381	* ip address is included.	1499	* ip address is included.
1382	*/	1500	*/
1383	if (op->type == PLAYER && !battleg) {	1501	if (op->type == PLAYER && !battleg)
		1502	{
1384	time_t t=time(NULL);	1503	time_t t = time (NULL);
1385	struct tm *tmv;	1504	struct tm *tmv;
1386	char buf[256];	1505	char buf[256];
1387		1506
1388	tmv = localtime(&t);	1507	tmv = localtime (&t);
1389	strftime(buf, 256,"%a %b %d %H:%M:%S %Y", tmv);	1508	strftime (buf, 256, "%a %b %d %H:%M:%S %Y", tmv);
1390		1509
1391	LOG(llevInfo,"%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n",	1510	LOG (llevInfo, "%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n", buf, &owner->name, owner->contr->socket.host, query_name (op));
1392	buf, &owner->name, owner->contr->socket.host, query_name(op));
1393	}	1511	}
1394		1512
1395	/* try to filter some things out - basically, if you are	1513	/* try to filter some things out - basically, if you are
1396	* killing a level 1 creature and your level 20, you	1514	* killing a level 1 creature and your level 20, you
1397	* probably don't want to see that.	1515	* probably don't want to see that.
1398	*/	1516	*/
1399	if ( owner->level < op->level * 2|| op->stats.exp>1000) {	1517	if (owner->level < op->level * 2 || op->stats.exp > 1000)
		1518	{
1400	if(owner!=hitter) {	1519	if (owner != hitter)
1401	new_draw_info_format(NDI_BLACK, 0, owner,	1520	{
1402	"You killed %s with %s.",query_name(op),	1521	new_draw_info_format (NDI_BLACK, 0, owner, "You killed %s with %s.", query_name (op), query_name (hitter));
1403	query_name(hitter));
1404	}	1522	}
1405	else {	1523	else
1406	new_draw_info_format(NDI_BLACK, 0, owner,	1524	{
1407	"You killed %s.",query_name(op));	1525	new_draw_info_format (NDI_BLACK, 0, owner, "You killed %s.", query_name (op));
1408	}	1526	}
1409	/* Only play sounds for melee kills */	1527	/* Only play sounds for melee kills */
1410	if (hitter->type == PLAYER)	1528	if (hitter->type == PLAYER)
1411	play_sound_map(owner->map, owner->x, owner->y, SOUND_PLAYER_KILLS);	1529	play_sound_map (owner->map, owner->x, owner->y, SOUND_PLAYER_KILLS);
1412	}	1530	}
1413		1531
1414	/* If a player kills another player, not on	1532	/* If a player kills another player, not on
1415	* battleground, the "killer" looses 1 luck. Since this is	1533	* battleground, the "killer" looses 1 luck. Since this is
1416	* not reversible, it's actually quite a pain IMHO. -AV	1534	* not reversible, it's actually quite a pain IMHO. -AV
1417	* Fix bug in that we were changing the luck of the hitter, not	1535	* Fix bug in that we were changing the luck of the hitter, not
1418	* player that the object belonged to - so if you killed another player	1536	* player that the object belonged to - so if you killed another player
1419	* with spells, pets, whatever, there was no penalty.	1537	* with spells, pets, whatever, there was no penalty.
1420	* Changed to make luck penalty configurable in settings.	1538	* Changed to make luck penalty configurable in settings.
1421	*/	1539	*/
1422	if(op->type == PLAYER && owner != op && !battleg)	1540	if (op->type == PLAYER && owner != op && !battleg)
1423	change_luck(owner, -settings.pk_luck_penalty);	1541	change_luck (owner, -settings.pk_luck_penalty);
1424		1542
1425	/* This code below deals with finding the appropriate skill	1543	/* This code below deals with finding the appropriate skill
1426	* to credit exp to. This is a bit problematic - we should	1544	* to credit exp to. This is a bit problematic - we should
1427	* probably never really have to look at current_weapon->skill	1545	* probably never really have to look at current_weapon->skill
1428	*/	1546	*/
1429	skill = NULL;	1547	skill = NULL;
1430	if (hitter->skill && hitter->type!=PLAYER) skill = hitter->skill;	1548	if (hitter->skill && hitter->type != PLAYER)
		1549	skill = hitter->skill;
1431	else if (owner->chosen_skill) {	1550	else if (owner->chosen_skill)
		1551	{
1432	skill = owner->chosen_skill->skill;	1552	skill = owner->chosen_skill->skill;
1433	skop = owner->chosen_skill;	1553	skop = owner->chosen_skill;
1434	}	1554	}
1435	else if (QUERY_FLAG(owner, FLAG_READY_WEAPON)) skill=owner->current_weapon->skill;	1555	else if (QUERY_FLAG (owner, FLAG_READY_WEAPON))
		1556	skill = owner->current_weapon->skill;
1436	else	1557	else
1437	LOG(llevError,"kill_object - unable to find skill that killed monster\n");	1558	LOG (llevError, "kill_object - unable to find skill that killed monster\n");
1438		1559
1439	/* We have the skill we want to credit to - now find the object this goes	1560	/* We have the skill we want to credit to - now find the object this goes
1440	* to. Make sure skop is an actual skill, and not a skill tool!	1561	* to. Make sure skop is an actual skill, and not a skill tool!
1441	*/	1562	*/
1442	if ((!skop || skop->type != SKILL) && skill) {	1563	if ((!skop || skop->type != SKILL) && skill)
		1564	{
1443	int i;	1565	int i;
1444		1566
1445	for (i=0; i<NUM_SKILLS; i++)	1567	for (i = 0; i < NUM_SKILLS; i++)
1446	if (owner->contr->last_skill_ob[i] &&	1568	if (owner->contr->last_skill_ob[i] && !strcmp (owner->contr->last_skill_ob[i]->skill, skill))
1447	!strcmp(owner->contr->last_skill_ob[i]->skill, skill)) {	1569	{
1448	skop = owner->contr->last_skill_ob[i];	1570	skop = owner->contr->last_skill_ob[i];
1449	break;	1571	break;
1450	}	1572	}
1451	}	1573	}
1452	} /* Was it a player that hit somethign */	1574	} /* Was it a player that hit somethign */
1453	else {	1575	else
		1576	{
1454	skill = NULL;	1577	skill = NULL;
1455	}	1578	}
1456		1579
1457	/* Pet (or spell) killed something. */	1580	/* Pet (or spell) killed something. */
1458	if(owner != hitter ) {	1581	if (owner != hitter)
		1582	{
1459	(void) sprintf(buf,"%s killed %s with %s%s%s.",&owner->name,	1583	(void) sprintf (buf, "%s killed %s with %s%s%s.", &owner->name,
1460	query_name(op),query_name(hitter), battleg? " (duel)":"", pk? " (pk)":"");	1584	query_name (op), query_name (hitter), battleg ? " (duel)" : "", pk ? " (pk)" : "");
		1585	}
		1586	else
1461	}	1587	{
1462	else {
1463	(void) sprintf(buf,"%s killed %s%s%s%s.",&hitter->name,&op->name,	1588	(void) sprintf (buf, "%s killed %s%s%s%s.", &hitter->name, &op->name,
1464	(QUERY_FLAG(hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?	1589	(QUERY_FLAG (hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?
1465	" in hand to hand combat":"", battleg? " (duel)":"", pk? " (pk)":"");	1590	" in hand to hand combat" : "", battleg ? " (duel)" : "", pk ? " (pk)" : "");
1466	}	1591	}
1467	/* These may have been set in the player code section above */	1592	/* These may have been set in the player code section above */
		1593	if (!skop)
1468	if (!skop) skop = hitter->chosen_skill;	1594	skop = hitter->chosen_skill;
1469	if (!skill && skop) skill=skop->skill;	1595	if (!skill && skop)
		1596	skill = skop->skill;
1470		1597
1471	new_draw_info(NDI_ALL, op->type==PLAYER?1:10, NULL, buf);	1598	new_draw_info (NDI_ALL, op->type == PLAYER ? 1 : 10, NULL, buf);
1472		1599
1473		1600
1474	/* If you didn't kill yourself, and your not the wizard */	1601	/* If you didn't kill yourself, and your not the wizard */
1475	if(owner!=op && !QUERY_FLAG(op, FLAG_WAS_WIZ)) {	1602	if (owner != op && !QUERY_FLAG (op, FLAG_WAS_WIZ))
		1603	{
1476	int exp;	1604	int exp;
1477		1605
1478	/* Really don't give much experience for killing other players */	1606	/* Really don't give much experience for killing other players */
1479	// schmorp: temporary? reduce the amount of exp gained for pking enourmously	1607	// schmorp: temporary? reduce the amount of exp gained for pking enourmously
1480	if (op->type==PLAYER) {	1608	if (op->type == PLAYER)
		1609	{
1481	if (battleg) {	1610	if (battleg)
		1611	{
1482	new_draw_info(NDI_UNIQUE, 0,owner, "Your foe has fallen!");	1612	new_draw_info (NDI_UNIQUE, 0, owner, "Your foe has fallen!");
1483	new_draw_info(NDI_UNIQUE, 0,owner, "VICTORY!!!");	1613	new_draw_info (NDI_UNIQUE, 0, owner, "VICTORY!!!");
1484	}	1614	}
1485	else	1615	else
1486	exp = op->stats.exp / 1000;	1616	exp = op->stats.exp / 1000;
1487	}	1617	}
1488	else	1618	else
1489	exp = calc_skill_exp(owner, op, skop);	1619	exp = calc_skill_exp (owner, op, skop);
1490		1620
1491	/* if op is standing on "battleground" (arena), no way to gain	1621	/* if op is standing on "battleground" (arena), no way to gain
1492	* exp by killing him	1622	* exp by killing him
1493	*/	1623	*/
1494	if (battleg) exp = 0;	1624	if (battleg)
		1625	exp = 0;
1495		1626
1496	/* Don't know why this is set this way - doesn't make	1627	/* Don't know why this is set this way - doesn't make
1497	* sense to just divide everything by two for no reason.	1628	* sense to just divide everything by two for no reason.
1498	*/	1629	*/
1499		1630
1500	if (!settings.simple_exp)	1631	if (!settings.simple_exp)
1501	exp=exp/2;	1632	exp = exp / 2;
1502		1633
1503	if(owner->type!=PLAYER || owner->contr->party==NULL) {	1634	if (owner->type != PLAYER || owner->contr->party == NULL)
		1635	{
1504	change_exp(owner,exp, skill, 0);	1636	change_exp (owner, exp, skill, 0);
		1637	}
		1638	else
1505	}	1639	{
1506	else {
1507	int shares=0,count=0;	1640	int shares = 0, count = 0;
1508		1641
1509	player *pl;	1642	player *pl;
1510		1643
1511	partylist *party=owner->contr->party;	1644	partylist *party = owner->contr->party;
		1645
1512	#ifdef PARTY_KILL_LOG	1646	#ifdef PARTY_KILL_LOG
1513	add_kill_to_party(party, query_name(owner), query_name(op), exp);	1647	add_kill_to_party (party, query_name (owner), query_name (op), exp);
1514	#endif	1648	#endif
1515	for(pl=first_player;pl!=NULL;pl=pl->next) {	1649	for (pl = first_player; pl != NULL; pl = pl->next)
		1650	{
1516	if(party && pl->ob->contr->party==party && on_same_map(pl->ob, owner)) {	1651	if (party && pl->ob->contr->party == party && on_same_map (pl->ob, owner))
		1652	{
1517	count++;	1653	count++;
1518	shares+=(pl->ob->level+4);	1654	shares += (pl->ob->level + 4);
1519	}	1655	}
1520	}	1656	}
1521	if(count==1 || shares>exp)	1657	if (count == 1 || shares > exp)
1522	change_exp(owner,exp, skill, SK_EXP_TOTAL);	1658	change_exp (owner, exp, skill, SK_EXP_TOTAL);
1523	else {	1659	else
		1660	{
1524	int share=exp/shares,given=0,nexp;	1661	int share = exp / shares, given = 0, nexp;
		1662
1525	for(pl=first_player;pl!=NULL;pl=pl->next) {	1663	for (pl = first_player; pl != NULL; pl = pl->next)
		1664	{
1526	if(party && pl->ob->contr->party==party && on_same_map(pl->ob, owner)) {	1665	if (party && pl->ob->contr->party == party && on_same_map (pl->ob, owner))
		1666	{
1527	nexp=(pl->ob->level+4)*share;	1667	nexp = (pl->ob->level + 4) * share;
1528	change_exp(pl->ob,nexp, skill, SK_EXP_TOTAL);	1668	change_exp (pl->ob, nexp, skill, SK_EXP_TOTAL);
1529	given+=nexp;	1669	given += nexp;
1530	}	1670	}
1531	}	1671	}
1532	exp-=given;	1672	exp -= given;
1533	/* give any remainder to the player */	1673	/* give any remainder to the player */
1534	change_exp(owner,exp, skill, SK_EXP_ADD_SKILL);	1674	change_exp (owner, exp, skill, SK_EXP_ADD_SKILL);
1535	}	1675	}
1536	} /* else part of a party */	1676	} /* else part of a party */
1537		1677
1538	} /* end if person didn't kill himself */	1678	} /* end if person didn't kill himself */
1539		1679
1540	if(op->type!=PLAYER) {	1680	if (op->type != PLAYER)
		1681	{
1541	if(QUERY_FLAG(op,FLAG_FRIENDLY)) {	1682	if (QUERY_FLAG (op, FLAG_FRIENDLY))
		1683	{
1542	object *owner1 = get_owner(op);	1684	object *owner1 = get_owner (op);
1543		1685
1544	if(owner1!= NULL && owner1->type == PLAYER) {	1686	if (owner1 != NULL && owner1->type == PLAYER)
		1687	{
1545	play_sound_player_only(owner1->contr, SOUND_PET_IS_KILLED,0,0);	1688	play_sound_player_only (owner1->contr, SOUND_PET_IS_KILLED, 0, 0);
1546	/* Maybe we should include the owner that killed this, maybe not */	1689	/* Maybe we should include the owner that killed this, maybe not */
1547	new_draw_info_format(NDI_UNIQUE, 0,owner1,"Your pet, the %s, is killed by %s.",	1690	new_draw_info_format (NDI_UNIQUE, 0, owner1, "Your pet, the %s, is killed by %s.", &op->name, &hitter->name);
1548	&op->name,&hitter->name);
1549	}	1691	}
1550	remove_friendly_object(op);	1692	remove_friendly_object (op);
1551	}	1693	}
1552	remove_ob(op);	1694	remove_ob (op);
1553	free_object(op);	1695	free_object (op);
1554	}	1696	}
1555	/* Player has been killed! */	1697	/* Player has been killed! */
1556	else {	1698	else
		1699	{
1557	if(owner->type==PLAYER) {	1700	if (owner->type == PLAYER)
		1701	{
1558	snprintf(op->contr->killer, BIG_NAME, "%s the %s", &owner->name, owner->contr->title);	1702	snprintf (op->contr->killer, BIG_NAME, "%s the %s", &owner->name, owner->contr->title);
		1703	}
		1704	else
1559	}	1705	{
1560	else {
1561	strncpy(op->contr->killer,hitter->name,BIG_NAME);	1706	strncpy (op->contr->killer, hitter->name, BIG_NAME);
1562	op->contr->killer[BIG_NAME-1]='\0';	1707	op->contr->killer[BIG_NAME - 1] = '\0';
1563	}	1708	}
1564	}	1709	}
1565	/* This was return -1 - that doesn't seem correct - if we return -1, process	1710	/* This was return -1 - that doesn't seem correct - if we return -1, process
1566	* continues in the calling function.	1711	* continues in the calling function.
1567	*/	1712	*/
1568	return maxdam;	1713	return maxdam;
1569	}	1714	}
1570		1715
1571	/* Find out if this is friendly fire (PVP and attacker is peaceful) or not	1716	/* Find out if this is friendly fire (PVP and attacker is peaceful) or not
1572	* Returns 0 this is not friendly fire	1717	* Returns 0 this is not friendly fire
1573	*/	1718	*/
1574		1719
		1720	int
1575	int friendly_fire(object *op, object *hitter){	1721	friendly_fire (object *op, object *hitter)
		1722	{
1576	object *owner;	1723	object *owner;
1577	int friendlyfire;	1724	int friendlyfire;
1578
1579	if (hitter->head) hitter=hitter->head;
1580		1725
		1726	if (hitter->head)
		1727	hitter = hitter->head;
		1728
1581	friendlyfire = 0;	1729	friendlyfire = 0;
1582		1730
1583	if(op->type == PLAYER) {	1731	if (op->type == PLAYER)
		1732	{
1584	if (op_on_battleground (hitter, 0, 0))	1733	if (op_on_battleground (hitter, 0, 0))
1585	return 0;	1734	return 0;
1586		1735
1587	if(hitter->type == PLAYER && hitter->contr->peaceful == 1)	1736	if (hitter->type == PLAYER && hitter->contr->peaceful == 1)
1588	return 1;	1737	return 1;
1589		1738
1590	if((owner = get_owner(hitter))!=NULL) {	1739	if ((owner = get_owner (hitter)) != NULL)
		1740	{
1591	if(owner->type == PLAYER && owner->contr->peaceful == 1)	1741	if (owner->type == PLAYER && owner->contr->peaceful == 1)
1592	friendlyfire = 2;	1742	friendlyfire = 2;
1593	}	1743	}
1594		1744
1595	if (hitter->type == SPELL || hitter->type == POISONING ||	1745	if (hitter->type == SPELL || hitter->type == POISONING || hitter->type == DISEASE || hitter->type == RUNE)
1596	hitter->type == DISEASE || hitter->type == RUNE)
1597	friendlyfire = 0;	1746	friendlyfire = 0;
1598	}	1747	}
1599	return friendlyfire;	1748	return friendlyfire;
1600	}	1749	}
1601		1750
1602		1751
1603	/* This isn't used just for players, but in fact most objects.	1752	/* This isn't used just for players, but in fact most objects.
1604	* op is the object to be hit, dam is the amount of damage, hitter	1753	* op is the object to be hit, dam is the amount of damage, hitter
…		…
1609	*/	1758	*/
1610		1759
1611	/* Oct 95 - altered the following slightly for MULTIPLE_GODS hack	1760	/* Oct 95 - altered the following slightly for MULTIPLE_GODS hack
1612	* which needs new attacktype AT_HOLYWORD to work . b.t. */	1761	* which needs new attacktype AT_HOLYWORD to work . b.t. */
1613		1762
		1763	int
1614	int hit_player(object *op,int dam, object *hitter, int type, int full_hit) {	1764	hit_player (object *op, int dam, object *hitter, int type, int full_hit)
		1765	{
1615	int maxdam=0, ndam=0, attacktype=1, magic=(type & AT_MAGIC);	1766	int maxdam = 0, ndam = 0, attacktype = 1, magic = (type & AT_MAGIC);
1616	int maxattacktype, attacknum;	1767	int maxattacktype, attacknum;
1617	int body_attack = op && op->head; /* Did we hit op's head? */	1768	int body_attack = op && op->head; /* Did we hit op's head? */
1618	int simple_attack;	1769	int simple_attack;
1619	tag_t op_tag, hitter_tag;	1770	tag_t op_tag, hitter_tag;
1620	int rtn_kill = 0;	1771	int rtn_kill = 0;
1621	int friendlyfire;	1772	int friendlyfire;
1622		1773
1623	if (get_attack_mode (&op, &hitter, &simple_attack))	1774	if (get_attack_mode (&op, &hitter, &simple_attack))
1624	return 0;	1775	return 0;
1625		1776
1626	/* very simple: if our target has no_damage 1 set or is wiz, we can't hurt him */	1777	/* very simple: if our target has no_damage 1 set or is wiz, we can't hurt him */
1627	if (QUERY_FLAG (op, FLAG_WIZ) || QUERY_FLAG (op, FLAG_NO_DAMAGE))	1778	if (QUERY_FLAG (op, FLAG_WIZ) || QUERY_FLAG (op, FLAG_NO_DAMAGE))
1628	return 0;	1779	return 0;
1629		1780
1630	#ifdef PROHIBIT_PLAYERKILL	1781	#ifdef PROHIBIT_PLAYERKILL
1631	if (op->type == PLAYER) {	1782	if (op->type == PLAYER)
		1783	{
1632	object *owner = get_owner (hitter);	1784	object *owner = get_owner (hitter);
		1785
		1786	if (!owner)
1633	if (!owner) owner = hitter;	1787	owner = hitter;
1634	if (owner->type == PLAYER
1635	&& (!op_on_battleground (op, 0, 0) && (op->contr->peaceful || owner->contr->peaceful))	1788	if (owner->type == PLAYER && (!op_on_battleground (op, 0, 0) && (op->contr->peaceful || owner->contr->peaceful)) && op != owner)
1636	&& op != owner) {	1789	{
		1790	return 0;
		1791	}
		1792	}
		1793	#endif
		1794
		1795	op_tag = op->count;
		1796	hitter_tag = hitter->count;
		1797
		1798	if (body_attack)
		1799	{
		1800	/* slow and paralyze must hit the head. But we don't want to just
		1801	* return - we still need to process other attacks the spell still
		1802	* might have. So just remove the paralyze and slow attacktypes,
		1803	* and keep on processing if we have other attacktypes.
		1804	* return if only magic or nothing is left - under normal code
		1805	* we don't attack with pure magic if there is another attacktype.
		1806	* Only do processing if the initial attacktype includes one of those
		1807	* attack so we don't cancel out things like magic bullet.
		1808	*/
		1809	if (type & (AT_PARALYZE | AT_SLOW))
		1810	{
		1811	type &= ~(AT_PARALYZE | AT_SLOW);
		1812	if (!type || type == AT_MAGIC)
		1813	return 0;
		1814	}
		1815	}
		1816
		1817	if (!simple_attack && op->type == DOOR)
		1818	{
		1819	object *tmp;
		1820
		1821	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
		1822	if (tmp->type == RUNE || tmp->type == TRAP)
		1823	{
		1824	spring_trap (tmp, hitter);
		1825	if (was_destroyed (hitter, hitter_tag) || was_destroyed (op, op_tag) || abort_attack (op, hitter, simple_attack))
1637	return 0;	1826	return 0;
		1827	break;
1638	}	1828	}
		1829	}
		1830
		1831	if (!QUERY_FLAG (op, FLAG_ALIVE) || op->stats.hp < 0)
1639	}	1832	{
		1833	/* FIXME: If a player is killed by a rune in a door, the
		1834	* was_destroyed() check above doesn't return, and might get here.
		1835	*/
		1836	LOG (llevDebug, "victim (arch %s, name %s) already dead in " "hit_player()\n", &op->arch->name, &op->name);
		1837	return 0;
		1838	}
		1839
		1840	#ifdef ATTACK_DEBUG
		1841	LOG (llevDebug, "hit player: attacktype %d, dam %d\n", type, dam);
1640	#endif	1842	#endif
1641		1843
1642	op_tag = op->count;
1643	hitter_tag = hitter->count;
1644
1645	if (body_attack) {
1646	/* slow and paralyze must hit the head. But we don't want to just
1647	* return - we still need to process other attacks the spell still
1648	* might have. So just remove the paralyze and slow attacktypes,
1649	* and keep on processing if we have other attacktypes.
1650	* return if only magic or nothing is left - under normal code
1651	* we don't attack with pure magic if there is another attacktype.
1652	* Only do processing if the initial attacktype includes one of those
1653	* attack so we don't cancel out things like magic bullet.
1654	*/
1655	if (type & (AT_PARALYZE | AT_SLOW)) {
1656	type &= ~(AT_PARALYZE | AT_SLOW);
1657	if (!type || type==AT_MAGIC) return 0;
1658	}
1659	}
1660
1661	if ( ! simple_attack && op->type == DOOR) {
1662	object *tmp;
1663	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
1664	if (tmp->type == RUNE || tmp->type == TRAP) {
1665	spring_trap (tmp, hitter);
1666	if (was_destroyed (hitter, hitter_tag)
1667	|| was_destroyed (op, op_tag)
1668	|| abort_attack (op, hitter, simple_attack))
1669	return 0;
1670	break;
1671	}
1672	}
1673
1674	if ( ! QUERY_FLAG (op, FLAG_ALIVE) || op->stats.hp < 0) {
1675	/* FIXME: If a player is killed by a rune in a door, the
1676	* was_destroyed() check above doesn't return, and might get here.
1677	*/
1678	LOG (llevDebug, "victim (arch %s, name %s) already dead in "
1679	"hit_player()\n", &op->arch->name, &op->name);
1680	return 0;
1681	}
1682
1683	#ifdef ATTACK_DEBUG
1684	LOG(llevDebug,"hit player: attacktype %d, dam %d\n", type, dam);
1685	#endif
1686
1687	if (magic) {	1844	if (magic)
		1845	{
1688	/* basically: dam = dam*(100-op->resist[attacknum])/100;	1846	/* basically: dam = dam*(100-op->resist[attacknum])/100;
1689	* in case 0>dam>1, we try to "simulate" a float value-effect */	1847	* in case 0>dam>1, we try to "simulate" a float value-effect */
1690	dam = dam*(100-op->resist[ATNR_MAGIC]);	1848	dam = dam * (100 - op->resist[ATNR_MAGIC]);
1691	if (dam >= 100)	1849	if (dam >= 100)
1692	dam /= 100;	1850	dam /= 100;
1693	else	1851	else
1694	dam = (dam > (rndm(0, 99))) ? 1 : 0;	1852	dam = (dam > (rndm (0, 99))) ? 1 : 0;
1695	}	1853	}
1696		1854
1697	/* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map	1855	/* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map
1698	* If the attacktype still has chaos, shuffle it, then clear the Chaos bit	1856	* If the attacktype still has chaos, shuffle it, then clear the Chaos bit
1699	*/	1857	*/
1700	if(type & AT_CHAOS){	1858	if (type & AT_CHAOS)
		1859	{
1701	shuffle_attack(op,0); /*0 flag tells it to not change the face */	1860	shuffle_attack (op, 0); /*0 flag tells it to not change the face */
1702	update_object(op,UP_OBJ_FACE);	1861	update_object (op, UP_OBJ_FACE);
1703	type &= ~AT_CHAOS;	1862	type &= ~AT_CHAOS;
1704	}	1863	}
1705		1864
1706	/* Holyword is really an attacktype modifier (like magic is). If	1865	/* Holyword is really an attacktype modifier (like magic is). If
1707	* holyword is part of an attacktype, then make sure the creature is	1866	* holyword is part of an attacktype, then make sure the creature is
1708	* a proper match, otherwise no damage.	1867	* a proper match, otherwise no damage.
1709	*/	1868	*/
1710	if (type & AT_HOLYWORD) {	1869	if (type & AT_HOLYWORD)
		1870	{
1711	object *god;	1871	object *god;
		1872
1712	if ((!hitter->slaying ||	1873	if ((!hitter->slaying ||
1713	(!(op->race && strstr(hitter->slaying,op->race)) &&	1874	(!(op->race && strstr (hitter->slaying, op->race)) &&
1714	!(op->name && strstr(hitter->slaying,op->name)))) &&	1875	!(op->name && strstr (hitter->slaying, op->name)))) &&
1715	(!QUERY_FLAG(op,FLAG_UNDEAD) ||	1876	(!QUERY_FLAG (op, FLAG_UNDEAD) ||
1716	(hitter->title != NULL	1877	(hitter->title != NULL
1717	&& (god = find_god(determine_god(hitter))) != NULL	1878	&& (god = find_god (determine_god (hitter))) != NULL && god->race != NULL && strstr (god->race, undead_name) != NULL)))
1718	&& god->race != NULL
1719	&& strstr(god->race,undead_name) != NULL)))
1720	return 0;	1879	return 0;
1721	}	1880	}
1722		1881
1723	maxattacktype = type; /* initialize this to something */	1882	maxattacktype = type; /* initialize this to something */
1724	for (attacknum=0; attacknum<NROFATTACKS; attacknum++, attacktype=1<<attacknum) {	1883	for (attacknum = 0; attacknum < NROFATTACKS; attacknum++, attacktype = 1 << attacknum)
		1884	{
1725	/* Magic isn't really a true attack type - it gets combined with other	1885	/* Magic isn't really a true attack type - it gets combined with other
1726	* attack types. As such, skip it over. However, if magic is	1886	* attack types. As such, skip it over. However, if magic is
1727	* the only attacktype in the group, then still attack with it	1887	* the only attacktype in the group, then still attack with it
1728	*/	1888	*/
1729	if ((attacktype==AT_MAGIC) && (type & ~AT_MAGIC)) continue;	1889	if ((attacktype == AT_MAGIC) && (type & ~AT_MAGIC))
		1890	continue;
1730		1891
1731	/* Go through and hit the player with each attacktype, one by one.	1892	/* Go through and hit the player with each attacktype, one by one.
1732	* hit_player_attacktype only figures out the damage, doesn't inflict	1893	* hit_player_attacktype only figures out the damage, doesn't inflict
1733	* it. It will do the appropriate action for attacktypes with	1894	* it. It will do the appropriate action for attacktypes with
1734	* effects (slow, paralization, etc.	1895	* effects (slow, paralization, etc.
1735	*/	1896	*/
1736	if (type & attacktype) {	1897	if (type & attacktype)
		1898	{
1737	ndam=hit_player_attacktype(op,hitter,dam,attacknum,magic);	1899	ndam = hit_player_attacktype (op, hitter, dam, attacknum, magic);
1738	/* the >= causes us to prefer messages from special attacks, if	1900	/* the >= causes us to prefer messages from special attacks, if
1739	* the damage is equal.	1901	* the damage is equal.
1740	*/	1902	*/
1741	if (ndam >= maxdam) {	1903	if (ndam >= maxdam)
		1904	{
1742	maxdam = ndam;	1905	maxdam = ndam;
1743	maxattacktype = 1<<attacknum;	1906	maxattacktype = 1 << attacknum;
1744	}	1907	}
1745	}	1908	}
1746	}	1909	}
1747		1910
1748	/* if this is friendly fire then do a set % of damage only	1911	/* if this is friendly fire then do a set % of damage only
1749	* Note - put a check in to make sure this attack is actually	1912	* Note - put a check in to make sure this attack is actually
1750	* doing damage - otherwise, the +1 in the code below will make	1913	* doing damage - otherwise, the +1 in the code below will make
1751	* an attack do damage before when it otherwise didn't	1914	* an attack do damage before when it otherwise didn't
1752	*/	1915	*/
1753	friendlyfire = friendly_fire(op, hitter);	1916	friendlyfire = friendly_fire (op, hitter);
1754	if (friendlyfire && maxdam){	1917	if (friendlyfire && maxdam)
		1918	{
1755	maxdam = ((dam * settings.set_friendly_fire) / 100);	1919	maxdam = ((dam * settings.set_friendly_fire) / 100);
1756	#ifndef COZY_SERVER	1920	#ifndef COZY_SERVER
		1921	maxdam++;
		1922	#endif
		1923
		1924	#ifdef ATTACK_DEBUG
		1925	LOG (llevDebug, "Friendly fire (type:%d setting: %d%) did %d damage dropped to %d\n",
		1926	friendlyfire, settings.set_friendly_fire, dam, maxdam);
		1927	#endif
		1928	}
		1929
		1930	if (!full_hit)
		1931	{
		1932	archetype *at;
		1933	int area;
		1934	int remainder;
		1935
		1936	area = 0;
		1937	for (at = op->arch; at != NULL; at = at->more)
		1938	area++;
		1939	assert (area > 0);
		1940
		1941	/* basically: maxdam /= area; we try to "simulate" a float
		1942	value-effect */
		1943	remainder = 100 * (maxdam % area) / area;
		1944	maxdam /= area;
		1945	if (RANDOM () % 100 < remainder)
1757	maxdam++;	1946	maxdam++;
		1947	}
		1948
		1949	#ifdef ATTACK_DEBUG
		1950	LOG (llevDebug, "Attacktype %d did %d damage\n", type, maxdam);
1758	#endif	1951	#endif
1759
1760	#ifdef ATTACK_DEBUG
1761	LOG(llevDebug,"Friendly fire (type:%d setting: %d%) did %d damage dropped to %d\n",
1762	friendlyfire, settings.set_friendly_fire, dam, maxdam);
1763	#endif
1764	}
1765		1952
1766	if (!full_hit) {
1767	archetype *at;
1768	int area;
1769	int remainder;
1770
1771	area = 0;
1772	for(at = op->arch; at != NULL; at = at->more)
1773	area++;
1774	assert(area > 0);
1775
1776	/* basically: maxdam /= area; we try to "simulate" a float
1777	value-effect */
1778	remainder = 100*(maxdam%area)/area;
1779	maxdam /= area;
1780	if (RANDOM()%100 < remainder)
1781	maxdam++;
1782	}
1783
1784	#ifdef ATTACK_DEBUG
1785	LOG(llevDebug,"Attacktype %d did %d damage\n", type, maxdam);
1786	#endif
1787
1788	if(get_owner(hitter))	1953	if (get_owner (hitter))
1789	op->enemy=hitter->owner;	1954	op->enemy = hitter->owner;
1790	else if (QUERY_FLAG(hitter,FLAG_ALIVE))	1955	else if (QUERY_FLAG (hitter, FLAG_ALIVE))
1791	op->enemy=hitter;	1956	op->enemy = hitter;
1792		1957
1793	if(QUERY_FLAG(op,FLAG_UNAGGRESSIVE) && op->type != PLAYER) {	1958	if (QUERY_FLAG (op, FLAG_UNAGGRESSIVE) && op->type != PLAYER)
		1959	{
1794	/* The unaggressives look after themselves 8) */	1960	/* The unaggressives look after themselves 8) */
1795	CLEAR_FLAG(op, FLAG_UNAGGRESSIVE);	1961	CLEAR_FLAG (op, FLAG_UNAGGRESSIVE);
1796	npc_call_help(op);	1962	npc_call_help (op);
1797	}	1963	}
1798		1964
1799	if (magic && did_make_save(op, op->level, 0))	1965	if (magic && did_make_save (op, op->level, 0))
1800	maxdam=maxdam/2;	1966	maxdam = maxdam / 2;
1801		1967
1802	attack_message(maxdam, maxattacktype, op, hitter);	1968	attack_message (maxdam, maxattacktype, op, hitter);
1803		1969
1804	op->stats.hp-=maxdam;	1970	op->stats.hp -= maxdam;
1805		1971
1806	/* Eneq(@csd.uu.se): Check to see if monster runs away. */	1972	/* Eneq(@csd.uu.se): Check to see if monster runs away. */
1807	if ((op->stats.hp>=0) &&	1973	if ((op->stats.hp >= 0) &&
1808	(QUERY_FLAG(op, FLAG_MONSTER) || op->type == PLAYER) &&	1974	(QUERY_FLAG (op, FLAG_MONSTER) || op->type == PLAYER) &&
1809	op->stats.hp<(signed short)(((float)op->run_away/(float)100)*	1975	op->stats.hp < (signed short) (((float) op->run_away / (float) 100) * (float) op->stats.maxhp))
1810	(float)op->stats.maxhp)) {	1976	{
1811		1977
1812	if (QUERY_FLAG(op, FLAG_MONSTER))	1978	if (QUERY_FLAG (op, FLAG_MONSTER))
1813	SET_FLAG(op, FLAG_RUN_AWAY);	1979	SET_FLAG (op, FLAG_RUN_AWAY);
1814	else	1980	else
1815	scare_creature(op, hitter);	1981	scare_creature (op, hitter);
1816	}	1982	}
1817		1983
1818	if(QUERY_FLAG(op,FLAG_TEAR_DOWN)) {	1984	if (QUERY_FLAG (op, FLAG_TEAR_DOWN))
		1985	{
1819	if (maxdam)	1986	if (maxdam)
1820	tear_down_wall(op);	1987	tear_down_wall (op);
1821	return maxdam; /* nothing more to do for wall */	1988	return maxdam; /* nothing more to do for wall */
1822	}	1989	}
1823		1990
1824	/* See if the creature has been killed */	1991	/* See if the creature has been killed */
1825	rtn_kill = kill_object(op, maxdam, hitter, type);	1992	rtn_kill = kill_object (op, maxdam, hitter, type);
1826	if (rtn_kill != -1)	1993	if (rtn_kill != -1)
1827	return rtn_kill;	1994	return rtn_kill;
1828		1995
1829		1996
1830	/* Used to be ghosthit removal - we now use the ONE_HIT flag. Note	1997	/* Used to be ghosthit removal - we now use the ONE_HIT flag. Note
1831	* that before if the player was immune to ghosthit, the monster	1998	* that before if the player was immune to ghosthit, the monster
1832	* remained - that is no longer the case.	1999	* remained - that is no longer the case.
1833	*/	2000	*/
1834	if(QUERY_FLAG(hitter, FLAG_ONE_HIT)) {	2001	if (QUERY_FLAG (hitter, FLAG_ONE_HIT))
		2002	{
1835	if(QUERY_FLAG(hitter,FLAG_FRIENDLY))	2003	if (QUERY_FLAG (hitter, FLAG_FRIENDLY))
1836	remove_friendly_object(hitter);	2004	remove_friendly_object (hitter);
1837	remove_ob(hitter);	2005	remove_ob (hitter);
1838	free_object(hitter);	2006	free_object (hitter);
1839	}	2007	}
1840	/* Lets handle creatures that are splitting now */	2008	/* Lets handle creatures that are splitting now */
1841	else if(type&AT_PHYSICAL&&!QUERY_FLAG(op, FLAG_FREED)&&QUERY_FLAG(op,FLAG_SPLITTING)) {	2009	else if (type & AT_PHYSICAL && !QUERY_FLAG (op, FLAG_FREED) && QUERY_FLAG (op, FLAG_SPLITTING))
		2010	{
1842	int i;	2011	int i;
1843	int friendly = QUERY_FLAG(op,FLAG_FRIENDLY);	2012	int friendly = QUERY_FLAG (op, FLAG_FRIENDLY);
1844	int unaggressive = QUERY_FLAG(op, FLAG_UNAGGRESSIVE);	2013	int unaggressive = QUERY_FLAG (op, FLAG_UNAGGRESSIVE);
1845	object *owner = get_owner(op);	2014	object *owner = get_owner (op);
1846		2015
1847	if(!op->other_arch) {	2016	if (!op->other_arch)
		2017	{
1848	LOG(llevError,"SPLITTING without other_arch error.\n");	2018	LOG (llevError, "SPLITTING without other_arch error.\n");
1849	return maxdam;	2019	return maxdam;
1850	}	2020	}
1851	remove_ob(op);	2021	remove_ob (op);
1852	for(i=0;i<NROFNEWOBJS(op);i++) { /* This doesn't handle op->more yet */	2022	for (i = 0; i < NROFNEWOBJS (op); i++)
		2023	{ /* This doesn't handle op->more yet */
1853	object *tmp=arch_to_object(op->other_arch);	2024	object *tmp = arch_to_object (op->other_arch);
1854	int j;	2025	int j;
1855		2026
1856	tmp->stats.hp=op->stats.hp;	2027	tmp->stats.hp = op->stats.hp;
1857	if (friendly) {	2028	if (friendly)
		2029	{
1858	SET_FLAG(tmp, FLAG_FRIENDLY);	2030	SET_FLAG (tmp, FLAG_FRIENDLY);
1859	add_friendly_object(tmp);	2031	add_friendly_object (tmp);
1860	tmp->attack_movement = PETMOVE;	2032	tmp->attack_movement = PETMOVE;
1861	if (owner!=NULL)	2033	if (owner != NULL)
1862	set_owner(tmp,owner);	2034	set_owner (tmp, owner);
1863	}	2035	}
1864	if (unaggressive)	2036	if (unaggressive)
1865	SET_FLAG(tmp, FLAG_UNAGGRESSIVE);	2037	SET_FLAG (tmp, FLAG_UNAGGRESSIVE);
1866	j=find_first_free_spot(tmp,op->map,op->x,op->y);	2038	j = find_first_free_spot (tmp, op->map, op->x, op->y);
1867	if (j==-1) /* No spot to put this monster */	2039	if (j == -1) /* No spot to put this monster */
1868	free_object(tmp);	2040	free_object (tmp);
1869	else {	2041	else
		2042	{
1870	tmp->x=op->x+freearr_x[j],tmp->y=op->y+freearr_y[j];	2043	tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j];
1871	insert_ob_in_map(tmp,op->map,NULL,0);	2044	insert_ob_in_map (tmp, op->map, NULL, 0);
1872	}	2045	}
1873	}	2046	}
1874	if(friendly)	2047	if (friendly)
1875	remove_friendly_object(op);	2048	remove_friendly_object (op);
1876	free_object(op);	2049	free_object (op);
1877	}	2050	}
1878	else if(type & AT_DRAIN && hitter->type==GRIMREAPER&&hitter->value++>10) {	2051	else if (type & AT_DRAIN && hitter->type == GRIMREAPER && hitter->value++ > 10)
		2052	{
1879	remove_ob(hitter);	2053	remove_ob (hitter);
1880	free_object(hitter);	2054	free_object (hitter);
1881	}	2055	}
1882	return maxdam;	2056	return maxdam;
1883	}	2057	}
1884		2058
1885		2059
		2060	void
1886	void poison_player(object *op, object *hitter, int dam)	2061	poison_player (object *op, object *hitter, int dam)
1887	{	2062	{
1888	archetype *at = find_archetype("poisoning");	2063	archetype *at = find_archetype ("poisoning");
1889	object *tmp=present_arch_in_ob(at,op);	2064	object *tmp = present_arch_in_ob (at, op);
1890		2065
1891	if(tmp==NULL) {	2066	if (tmp == NULL)
		2067	{
1892	if((tmp=arch_to_object(at))==NULL)	2068	if ((tmp = arch_to_object (at)) == NULL)
1893	LOG(llevError,"Failed to clone arch poisoning.\n");	2069	LOG (llevError, "Failed to clone arch poisoning.\n");
1894	else {	2070	else
		2071	{
1895	tmp = insert_ob_in_ob(tmp,op);	2072	tmp = insert_ob_in_ob (tmp, op);
1896	/* peterm: give poisoning some teeth. It should	2073	/* peterm: give poisoning some teeth. It should
1897	* be able to kill things better than it does:	2074	* be able to kill things better than it does:
1898	* damage should be dependent something--I choose to	2075	* damage should be dependent something--I choose to
1899	* do this: if it's a monster, the damage from the	2076	* do this: if it's a monster, the damage from the
1900	* poisoning goes as the level of the monster/2.	2077	* poisoning goes as the level of the monster/2.
1901	* If anything else, goes as damage.	2078	* If anything else, goes as damage.
1902	*/	2079	*/
1903		2080
1904	if(QUERY_FLAG(hitter,FLAG_ALIVE))	2081	if (QUERY_FLAG (hitter, FLAG_ALIVE))
1905	tmp->stats.dam += hitter->level/2;	2082	tmp->stats.dam += hitter->level / 2;
1906	else	2083	else
1907	tmp->stats.dam = dam;	2084	tmp->stats.dam = dam;
1908		2085
1909	copy_owner(tmp,hitter); /* so we get credit for poisoning kills */	2086	copy_owner (tmp, hitter); /* so we get credit for poisoning kills */
1910	if(hitter->skill && hitter->skill != tmp->skill) {	2087	if (hitter->skill && hitter->skill != tmp->skill)
		2088	{
1911	tmp->skill = hitter->skill;	2089	tmp->skill = hitter->skill;
1912	}	2090	}
1913		2091
1914	tmp->stats.food+=dam; /* more damage, longer poisoning */	2092	tmp->stats.food += dam; /* more damage, longer poisoning */
1915		2093
1916	if(op->type==PLAYER) {	2094	if (op->type == PLAYER)
		2095	{
1917	/* player looses stats, maximum is -10 of each */	2096	/* player looses stats, maximum is -10 of each */
1918	tmp->stats.Con= MAX(-(dam/4+1), -10);	2097	tmp->stats.Con = MAX (-(dam / 4 + 1), -10);
1919	tmp->stats.Str= MAX(-(dam/3+2), -10);	2098	tmp->stats.Str = MAX (-(dam / 3 + 2), -10);
1920	tmp->stats.Dex= MAX(-(dam/6+1), -10);	2099	tmp->stats.Dex = MAX (-(dam / 6 + 1), -10);
1921	tmp->stats.Int= MAX(-dam/7, -10);	2100	tmp->stats.Int = MAX (-dam / 7, -10);
1922	SET_FLAG(tmp,FLAG_APPLIED);	2101	SET_FLAG (tmp, FLAG_APPLIED);
1923	fix_player(op);	2102	fix_player (op);
1924	new_draw_info(NDI_UNIQUE, 0,op,"You suddenly feel very ill.");	2103	new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very ill.");
1925	}	2104	}
1926	if (hitter->type == PLAYER)	2105	if (hitter->type == PLAYER)
1927	new_draw_info_format(NDI_UNIQUE, 0, hitter, "You poison %s.", &op->name);	2106	new_draw_info_format (NDI_UNIQUE, 0, hitter, "You poison %s.", &op->name);
1928	else if (get_owner(hitter) != NULL && hitter->owner->type == PLAYER)	2107	else if (get_owner (hitter) != NULL && hitter->owner->type == PLAYER)
1929	new_draw_info_format(NDI_UNIQUE, 0, hitter->owner,	2108	new_draw_info_format (NDI_UNIQUE, 0, hitter->owner, "Your %s poisons %s.", &hitter->name, &op->name);
1930	"Your %s poisons %s.", &hitter->name, &op->name);
1931	}	2109	}
1932	tmp->speed_left=0;	2110	tmp->speed_left = 0;
1933	}	2111	}
1934	else	2112	else
1935	tmp->stats.food++;	2113	tmp->stats.food++;
1936	}	2114	}
1937		2115
		2116	void
1938	void slow_player(object *op,object *hitter,int dam)	2117	slow_player (object *op, object *hitter, int dam)
		2118	{
1939	{ archetype *at = find_archetype("slowness");	2119	archetype *at = find_archetype ("slowness");
1940	object *tmp;	2120	object *tmp;
		2121
1941	if(at == NULL) {	2122	if (at == NULL)
		2123	{
1942	LOG(llevError,"Can't find slowness archetype.\n");	2124	LOG (llevError, "Can't find slowness archetype.\n");
1943	}	2125	}
1944	if((tmp=present_arch_in_ob(at,op)) == NULL) {	2126	if ((tmp = present_arch_in_ob (at, op)) == NULL)
		2127	{
1945	tmp = arch_to_object(at);	2128	tmp = arch_to_object (at);
1946	tmp = insert_ob_in_ob(tmp,op);	2129	tmp = insert_ob_in_ob (tmp, op);
1947	new_draw_info(NDI_UNIQUE, 0,op,"The world suddenly moves very fast!");	2130	new_draw_info (NDI_UNIQUE, 0, op, "The world suddenly moves very fast!");
		2131	}
1948	} else	2132	else
1949	tmp->stats.food++;	2133	tmp->stats.food++;
1950	SET_FLAG(tmp, FLAG_APPLIED);	2134	SET_FLAG (tmp, FLAG_APPLIED);
1951	tmp->speed_left=0;	2135	tmp->speed_left = 0;
1952	fix_player(op);	2136	fix_player (op);
1953	}	2137	}
1954		2138
		2139	void
1955	void confuse_player(object *op, object *hitter, int dam)	2140	confuse_player (object *op, object *hitter, int dam)
1956	{	2141	{
1957	object *tmp;	2142	object *tmp;
1958	int maxduration;	2143	int maxduration;
1959		2144
1960	tmp = present_in_ob_by_name(FORCE,"confusion", op);	2145	tmp = present_in_ob_by_name (FORCE, "confusion", op);
1961	if(!tmp) {	2146	if (!tmp)
		2147	{
1962	tmp = get_archetype(FORCE_NAME);	2148	tmp = get_archetype (FORCE_NAME);
1963	tmp = insert_ob_in_ob(tmp,op);	2149	tmp = insert_ob_in_ob (tmp, op);
1964	}
1965		2150	}
		2151
1966	/* Duration added per hit and max. duration of confusion both depend	2152	/* Duration added per hit and max. duration of confusion both depend
1967	* on the player's resistance	2153	* on the player's resistance
1968	*/	2154	*/
1969	tmp->speed = 0.05;	2155	tmp->speed = 0.05;
1970	tmp->subtype = FORCE_CONFUSION;	2156	tmp->subtype = FORCE_CONFUSION;
1971	tmp->duration = 8 + MAX(1, 5*(100-op->resist[ATNR_CONFUSION])/100);	2157	tmp->duration = 8 + MAX (1, 5 * (100 - op->resist[ATNR_CONFUSION]) / 100);
1972	tmp->name = "confusion";	2158	tmp->name = "confusion";
1973	maxduration = MAX(2, 30*(100-op->resist[ATNR_CONFUSION])/100);	2159	maxduration = MAX (2, 30 * (100 - op->resist[ATNR_CONFUSION]) / 100);
1974	if( tmp->duration > maxduration)	2160	if (tmp->duration > maxduration)
1975	tmp->duration = maxduration;	2161	tmp->duration = maxduration;
1976		2162
1977	if(op->type == PLAYER && !QUERY_FLAG(op,FLAG_CONFUSED))	2163	if (op->type == PLAYER && !QUERY_FLAG (op, FLAG_CONFUSED))
1978	new_draw_info(NDI_UNIQUE, 0,op,"You suddenly feel very confused!");	2164	new_draw_info (NDI_UNIQUE, 0, op, "You suddenly feel very confused!");
1979	SET_FLAG(op, FLAG_CONFUSED);	2165	SET_FLAG (op, FLAG_CONFUSED);
1980	}	2166	}
1981		2167
		2168	void
1982	void blind_player(object *op, object *hitter, int dam)	2169	blind_player (object *op, object *hitter, int dam)
1983	{	2170	{
1984	object *tmp,*owner;	2171	object *tmp, *owner;
1985		2172
1986	/* Save some work if we know it isn't going to affect the player */	2173	/* Save some work if we know it isn't going to affect the player */
1987	if (op->resist[ATNR_BLIND]==100) return;	2174	if (op->resist[ATNR_BLIND] == 100)
		2175	return;
1988		2176
1989	tmp = present_in_ob(BLINDNESS,op);	2177	tmp = present_in_ob (BLINDNESS, op);
1990	if(!tmp) {	2178	if (!tmp)
		2179	{
1991	tmp = get_archetype("blindness");	2180	tmp = get_archetype ("blindness");
1992	SET_FLAG(tmp, FLAG_BLIND);	2181	SET_FLAG (tmp, FLAG_BLIND);
1993	SET_FLAG(tmp, FLAG_APPLIED);	2182	SET_FLAG (tmp, FLAG_APPLIED);
1994	/* use floats so we don't lose too much precision due to rounding errors.	2183	/* use floats so we don't lose too much precision due to rounding errors.
1995	* speed is a float anyways.	2184	* speed is a float anyways.
1996	*/	2185	*/
1997	tmp->speed = tmp->speed * (100.0 - (float)op->resist[ATNR_BLIND]) / 100;	2186	tmp->speed = tmp->speed * (100.0 - (float) op->resist[ATNR_BLIND]) / 100;
1998		2187
1999	tmp = insert_ob_in_ob(tmp,op);	2188	tmp = insert_ob_in_ob (tmp, op);
2000	change_abil(op,tmp); /* Mostly to display any messages */	2189	change_abil (op, tmp); /* Mostly to display any messages */
2001	fix_player(op); /* This takes care of some other stuff */	2190	fix_player (op); /* This takes care of some other stuff */
2002		2191
		2192	if (hitter->owner)
2003	if(hitter->owner) owner = get_owner(hitter);	2193	owner = get_owner (hitter);
		2194	else
2004	else owner = hitter;	2195	owner = hitter;
2005		2196
2006	new_draw_info_format(NDI_UNIQUE,0,owner,	2197	new_draw_info_format (NDI_UNIQUE, 0, owner, "Your attack blinds %s!", query_name (op));
2007	"Your attack blinds %s!",query_name(op));
2008	}	2198	}
2009	tmp->stats.food += dam;	2199	tmp->stats.food += dam;
2010	if(tmp->stats.food > 10) tmp->stats.food = 10;	2200	if (tmp->stats.food > 10)
		2201	tmp->stats.food = 10;
2011	}	2202	}
2012		2203
		2204	void
2013	void paralyze_player(object *op, object *hitter, int dam)	2205	paralyze_player (object *op, object *hitter, int dam)
2014	{	2206	{
2015	float effect,max;	2207	float effect, max;
		2208
2016	/* object *tmp; */	2209	/* object *tmp; */
2017		2210
2018	/* This is strange stuff... someone knows for what this is	2211	/* This is strange stuff... someone knows for what this is
2019	* written? Well, i think this can and should be removed	2212	* written? Well, i think this can and should be removed
2020	*/	2213	*/
2021		2214
2022	/*	2215	/*
2023	if((tmp=present(PARAIMAGE,op->map,op->x,op->y))==NULL) {	2216	if((tmp=present(PARAIMAGE,op->map,op->x,op->y))==NULL) {
2024	tmp=clone_arch(PARAIMAGE);	2217	tmp=clone_arch(PARAIMAGE);
2025	tmp->x=op->x,tmp->y=op->y;	2218	tmp->x=op->x,tmp->y=op->y;
2026	insert_ob_in_map(tmp,op->map,tmp,INS_NO_MERGE | INS_NO_WALK_ON);	2219	insert_ob_in_map(tmp,op->map,tmp,INS_NO_MERGE | INS_NO_WALK_ON);
2027	}	2220	}
2028	*/	2221	*/
2029		2222
2030	/* Do this as a float - otherwise, rounding might very well reduce this to 0 */	2223	/* Do this as a float - otherwise, rounding might very well reduce this to 0 */
2031	effect = (float)dam * 3.0 * (100.0 - op->resist[ATNR_PARALYZE]) / 100;	2224	effect = (float) dam *3.0 * (100.0 - op->resist[ATNR_PARALYZE]) / 100;
2032		2225
2033	if (effect==0) return;	2226	if (effect == 0)
		2227	return;
2034		2228
2035	op->speed_left-=FABS(op->speed)*effect;	2229	op->speed_left -= FABS (op->speed) * effect;
2036	/* tmp->stats.food+=(signed short) effect/op->speed; */	2230	/* tmp->stats.food+=(signed short) effect/op->speed; */
2037		2231
2038	/* max number of ticks to be affected for. */	2232	/* max number of ticks to be affected for. */
2039	max = (100 - op->resist[ATNR_PARALYZE])/ 2;	2233	max = (100 - op->resist[ATNR_PARALYZE]) / 2;
2040	if (op->speed_left< -(FABS(op->speed)*max))	2234	if (op->speed_left < -(FABS (op->speed) * max))
2041	op->speed_left = (float) -(FABS(op->speed)*max);	2235	op->speed_left = (float) -(FABS (op->speed) * max);
2042		2236
2043	/* tmp->stats.food = (signed short) (max/FABS(op->speed)); */	2237	/* tmp->stats.food = (signed short) (max/FABS(op->speed)); */
2044	}	2238	}
2045		2239
2046		2240
2047	/* Attempts to kill 'op'. hitter is the attack object, dam is	2241	/* Attempts to kill 'op'. hitter is the attack object, dam is
2048	* the computed damaged.	2242	* the computed damaged.
2049	*/	2243	*/
		2244	void
2050	void deathstrike_player(object *op, object *hitter, int *dam)	2245	deathstrike_player (object *op, object *hitter, int *dam)
2051	{	2246	{
2052	/* The intention of a death attack is to kill outright things	2247	/* The intention of a death attack is to kill outright things
2053	** that are a lot weaker than the attacker, have a chance of killing	2248	** that are a lot weaker than the attacker, have a chance of killing
2054	** things somewhat weaker than the caster, and no chance of	2249	** things somewhat weaker than the caster, and no chance of
2055	** killing something equal or stronger than the attacker.	2250	** killing something equal or stronger than the attacker.
2056	** Also, if a deathstrike attack has a slaying, any monster	2251	** Also, if a deathstrike attack has a slaying, any monster
2057	** whose name or race matches a comma-delimited list in the slaying	2252	** whose name or race matches a comma-delimited list in the slaying
2058	** field of the deathstriking object */	2253	** field of the deathstriking object */
2059		2254
2060	int atk_lev, def_lev, kill_lev;	2255	int atk_lev, def_lev, kill_lev;
2061		2256
2062	if(hitter->slaying)	2257	if (hitter->slaying)
2063	if(!( (QUERY_FLAG(op,FLAG_UNDEAD)&&strstr(hitter->slaying,undead_name)) ||	2258	if (!((QUERY_FLAG (op, FLAG_UNDEAD) && strstr (hitter->slaying, undead_name)) || (op->race && strstr (hitter->slaying, op->race))))
2064	(op->race&&strstr(hitter->slaying,op->race)))) return;	2259	return;
2065		2260
2066	def_lev = op->level;	2261	def_lev = op->level;
2067	if (def_lev < 1) {	2262	if (def_lev < 1)
		2263	{
2068	LOG (llevError, "BUG: arch %s, name %s with level < 1\n",	2264	LOG (llevError, "BUG: arch %s, name %s with level < 1\n", &op->arch->name, &op->name);
2069	&op->arch->name, &op->name);
2070	def_lev = 1;	2265	def_lev = 1;
2071	}	2266	}
2072	atk_lev = (hitter->chosen_skill?hitter->chosen_skill->level:hitter->level) / 2;	2267	atk_lev = (hitter->chosen_skill ? hitter->chosen_skill->level : hitter->level) / 2;
2073	/* LOG(llevDebug,"Deathstrike - attack level %d, defender level %d\n",	2268	/* LOG(llevDebug,"Deathstrike - attack level %d, defender level %d\n",
2074	atk_lev, def_lev); */	2269	atk_lev, def_lev); */
2075		2270
2076	if(atk_lev >= def_lev ){	2271	if (atk_lev >= def_lev)
		2272	{
2077	kill_lev = random_roll(0, atk_lev-1, hitter, PREFER_HIGH);	2273	kill_lev = random_roll (0, atk_lev - 1, hitter, PREFER_HIGH);
2078		2274
2079	/* Note that the below effectively means the ratio of the atk vs	2275	/* Note that the below effectively means the ratio of the atk vs
2080	* defener level is important - if level 52 character has very little	2276	* defener level is important - if level 52 character has very little
2081	* chance of killing a level 50 monster. This should probably be	2277	* chance of killing a level 50 monster. This should probably be
2082	* redone.	2278	* redone.
2083	*/	2279	*/
2084	if(kill_lev >= def_lev) {	2280	if (kill_lev >= def_lev)
		2281	{
2085	*dam = op->stats.hp+10; /* take all hp. they can still save for 1/2 */	2282	*dam = op->stats.hp + 10; /* take all hp. they can still save for 1/2 */
2086	/* I think this doesn't really do much. Because of	2283	/* I think this doesn't really do much. Because of
2087	* integer rounding, this only makes any difference if the	2284	* integer rounding, this only makes any difference if the
2088	* attack level is double the defender level.	2285	* attack level is double the defender level.
2089	*/	2286	*/
2090	*dam *= kill_lev / def_lev;	2287	*dam *= kill_lev / def_lev;
2091	}	2288	}
2092	} else {	2289	}
		2290	else
		2291	{
2093	*dam = 0; /* no harm done */	2292	*dam = 0; /* no harm done */
2094	}	2293	}
2095	}	2294	}
2096		2295
2097	/* thrown_item_effect() - handles any special effects of thrown	2296	/* thrown_item_effect() - handles any special effects of thrown
2098	* items (like attacking living creatures--a potion thrown at a	2297	* items (like attacking living creatures--a potion thrown at a
2099	* monster).	2298	* monster).
2100	*/	2299	*/
		2300	static void
2101	static void thrown_item_effect (object *hitter, object *victim)	2301	thrown_item_effect (object *hitter, object *victim)
2102	{	2302	{
2103	if(!QUERY_FLAG(hitter,FLAG_ALIVE)) {	2303	if (!QUERY_FLAG (hitter, FLAG_ALIVE))
		2304	{
2104	/* May not need a switch for just 2 types, but this makes it	2305	/* May not need a switch for just 2 types, but this makes it
2105	* easier for expansion.	2306	* easier for expansion.
2106	*/	2307	*/
2107	switch (hitter->type) {	2308	switch (hitter->type)
		2309	{
2108	case POTION:	2310	case POTION:
2109	/* should player get a save throw instead of checking magic protection? */	2311	/* should player get a save throw instead of checking magic protection? */
2110	if(QUERY_FLAG(victim,FLAG_ALIVE)&&!QUERY_FLAG(victim,FLAG_UNDEAD)	2312	if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_UNDEAD) && (victim->resist[ATNR_MAGIC] < 60))
2111	&&(victim->resist[ATNR_MAGIC]<60)) (void) apply_potion(victim,hitter);	2313	(void) apply_potion (victim, hitter);
2112	break;	2314	break;
2113		2315
2114	case POISON: /* poison drinks */	2316	case POISON: /* poison drinks */
2115	/* As with potions, should monster get a save? */	2317	/* As with potions, should monster get a save? */
2116	if(QUERY_FLAG(victim,FLAG_ALIVE)&&!QUERY_FLAG(victim,FLAG_UNDEAD)	2318	if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_UNDEAD) && (victim->resist[ATNR_POISON] < 60))
2117	&&(victim->resist[ATNR_POISON]<60)) apply_poison(victim,hitter);	2319	apply_poison (victim, hitter);
2118	break;	2320	break;
2119		2321
2120	/* Removed case statements that did nothing.	2322	/* Removed case statements that did nothing.
2121	* food may be poisonous, but monster must be willing to eat it,	2323	* food may be poisonous, but monster must be willing to eat it,
2122	* so we don't handle it here.	2324	* so we don't handle it here.
2123	* Containers should perhaps break open, but that code was disabled.	2325	* Containers should perhaps break open, but that code was disabled.
2124	*/	2326	*/
2125	}	2327	}
2126	}	2328	}
2127	}	2329	}
2128		2330
2129	/* adj_attackroll() - adjustments to attacks by various conditions */	2331	/* adj_attackroll() - adjustments to attacks by various conditions */
2130		2332
		2333	int
2131	int adj_attackroll (object *hitter, object *target) {	2334	adj_attackroll (object *hitter, object *target)
		2335	{
2132	object *attacker = hitter;	2336	object *attacker = hitter;
2133	int adjust=0;	2337	int adjust = 0;
2134		2338
2135	/* safety */	2339	/* safety */
2136	if(!target||!hitter||!hitter->map||!target->map||!on_same_map(hitter,target)) {	2340	if (!target || !hitter || !hitter->map || !target->map || !on_same_map (hitter, target))
		2341	{
2137	LOG (llevError, "BUG: adj_attackroll(): hitter and target not on same "	2342	LOG (llevError, "BUG: adj_attackroll(): hitter and target not on same " "map\n");
2138	"map\n");	2343	return 0;
		2344	}
		2345
		2346	/* aimed missiles use the owning object's sight */
		2347	if (is_aimed_missile (hitter))
		2348	{
		2349	if ((attacker = get_owner (hitter)) == NULL)
		2350	attacker = hitter;
		2351	/* A player who saves but hasn't quit still could have objects
		2352	* owned by him - need to handle that case to avoid crashes.
		2353	*/
		2354	if (QUERY_FLAG (attacker, FLAG_REMOVED))
		2355	attacker = hitter;
		2356	}
		2357	else if (!QUERY_FLAG (hitter, FLAG_ALIVE))
2139	return 0;	2358	return 0;
2140	}
2141		2359
2142	/* aimed missiles use the owning object's sight */
2143	if(is_aimed_missile(hitter)) {
2144	if ((attacker = get_owner(hitter))==NULL) attacker = hitter;
2145	/* A player who saves but hasn't quit still could have objects
2146	* owned by him - need to handle that case to avoid crashes.
2147	*/
2148	if (QUERY_FLAG(attacker, FLAG_REMOVED)) attacker = hitter;
2149	}
2150	else if(!QUERY_FLAG(hitter,FLAG_ALIVE))
2151	return 0;
2152
2153	/* determine the condtions under which we make an attack.	2360	/* determine the condtions under which we make an attack.
2154	* Add more cases, as the need occurs. */	2361	* Add more cases, as the need occurs. */
2155		2362
2156	if(!can_see_enemy(attacker,target)) {	2363	if (!can_see_enemy (attacker, target))
		2364	{
2157	/* target is unseen */	2365	/* target is unseen */
2158	if(target->invisible || QUERY_FLAG(attacker,FLAG_BLIND))	2366	if (target->invisible || QUERY_FLAG (attacker, FLAG_BLIND))
2159	adjust -= 10;	2367	adjust -= 10;
2160	/* dark map penalty for the hitter (lacks infravision if we got here). */	2368	/* dark map penalty for the hitter (lacks infravision if we got here). */
2161	else if(target->map&&target->map->darkness>0&&!stand_in_light(target))	2369	else if (target->map && target->map->darkness > 0 && !stand_in_light (target))
2162	adjust -= target->map->darkness;	2370	adjust -= target->map->darkness;
2163	}	2371	}
2164		2372
2165	if(QUERY_FLAG(attacker,FLAG_SCARED))	2373	if (QUERY_FLAG (attacker, FLAG_SCARED))
2166	adjust -= 3;	2374	adjust -= 3;
2167		2375
2168	if(QUERY_FLAG(target,FLAG_UNAGGRESSIVE))	2376	if (QUERY_FLAG (target, FLAG_UNAGGRESSIVE))
2169	adjust += 1;	2377	adjust += 1;
2170		2378
2171	if(QUERY_FLAG(target,FLAG_SCARED))	2379	if (QUERY_FLAG (target, FLAG_SCARED))
2172	adjust += 1;	2380	adjust += 1;
2173		2381
2174	if(QUERY_FLAG(attacker,FLAG_CONFUSED))	2382	if (QUERY_FLAG (attacker, FLAG_CONFUSED))
2175	adjust -= 3;	2383	adjust -= 3;
2176		2384
2177	/* if we attack at a different 'altitude' its harder */	2385	/* if we attack at a different 'altitude' its harder */
2178	if((attacker->move_type & target->move_type)==0)	2386	if ((attacker->move_type & target->move_type) == 0)
2179	adjust -= 2;	2387	adjust -= 2;
2180		2388
2181	#if 0	2389	#if 0
2182	/* slower attacks are less likely to succeed. We should use a	2390	/* slower attacks are less likely to succeed. We should use a
2183	* comparison between attacker/target speeds BUT, players have	2391	* comparison between attacker/target speeds BUT, players have
2184	* a generally faster speed, so this will wind up being a HUGE	2392	* a generally faster speed, so this will wind up being a HUGE
2185	* disadantage for the monsters! Too bad, because missiles which	2393	* disadantage for the monsters! Too bad, because missiles which
2186	* fly fast should have a better chance of hitting a slower target.	2394	* fly fast should have a better chance of hitting a slower target.
2187	*/	2395	*/
2188	if(hitter->speed<target->speed)	2396	if (hitter->speed < target->speed)
2189	adjust += ((float) hitter->speed-target->speed);	2397	adjust += ((float) hitter->speed - target->speed);
2190	#endif	2398	#endif
2191		2399
2192	#if 0	2400	#if 0
2193	LOG(llevDebug,"adj_attackroll() returns %d (%d)\n",adjust,attacker->count);	2401	LOG (llevDebug, "adj_attackroll() returns %d (%d)\n", adjust, attacker->count);
2194	#endif	2402	#endif
2195		2403
2196	return adjust;	2404	return adjust;
2197	}	2405	}
2198		2406
2199		2407
2200	/* determine if the object is an 'aimed' missile */	2408	/* determine if the object is an 'aimed' missile */
		2409	int
2201	int is_aimed_missile ( object *op) {	2410	is_aimed_missile (object *op)
		2411	{
2202		2412
2203	/* I broke what used to be one big if into a few nested	2413	/* I broke what used to be one big if into a few nested
2204	* ones so that figuring out the logic is at least possible.	2414	* ones so that figuring out the logic is at least possible.
2205	*/	2415	*/
2206	if (op && (op->move_type & MOVE_FLYING)) {	2416	if (op && (op->move_type & MOVE_FLYING))
		2417	{
2207	if (op->type==ARROW || op->type==THROWN_OBJ)	2418	if (op->type == ARROW || op->type == THROWN_OBJ)
2208	return 1;	2419	return 1;
2209	else if (op->type==SPELL_EFFECT && (op->subtype == SP_BULLET ||	2420	else if (op->type == SPELL_EFFECT && (op->subtype == SP_BULLET || op->subtype == SP_EXPLOSION))
2210	op->subtype == SP_EXPLOSION))
2211	return 1;	2421	return 1;
2212	}	2422	}
2213	return 0;	2423	return 0;
2214	}	2424	}
2215

Diff Legend

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