[ViewVC] Diff of: cvs/deliantra/server/server/attack.C

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

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

Diff Legend

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

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

Diff Legend

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