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.4 by root, Tue Aug 29 07:34:00 2006 UTC vs.
Revision 1.5 by root, Tue Aug 29 08:01:37 2006 UTC

1	/*	1	/*
2	* static char *rcsid_attack_c =	2	* static char *rcsid_attack_c =
3	* "$Id: attack.C,v 1.4 2006/08/29 07:34:00 root Exp $";	3	* "$Id: attack.C,v 1.5 2006/08/29 08:01:37 root Exp $";
4	*/	4	*/
5	/*	5	/*
6	CrossFire, A Multiplayer game for X-windows	6	CrossFire, A Multiplayer game for X-windows
7		7
8	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	8	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
…		…
49	void cancellation(object *op)	49	void cancellation(object *op)
50	{	50	{
51	object *tmp;	51	object *tmp;
52		52
53	if (op->invisible)	53	if (op->invisible)
54	return;	54	return;
55		55
56	if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ) {	56	if (QUERY_FLAG (op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ) {
57	/* Recur through the inventory */	57	/* Recur through the inventory */
58	for(tmp=op->inv;tmp!=NULL;tmp=tmp->below)	58	for(tmp=op->inv;tmp!=NULL;tmp=tmp->below)
59	if (!did_make_save_item(tmp, AT_CANCELLATION,op))	59	if (!did_make_save_item(tmp, AT_CANCELLATION,op))
60	cancellation(tmp);	60	cancellation(tmp);
61	}	61	}
62	else if(FABS(op->magic)<=(rndm(0, 5))) {	62	else if(FABS(op->magic)<=(rndm(0, 5))) {
63	/* Nullify this object. This code could probably be more complete */	63	/* Nullify this object. This code could probably be more complete */
64	/* in what abilities it should cancel */	64	/* in what abilities it should cancel */
65	op->magic=0;	65	op->magic=0;
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	if (op->env && op->env->type == PLAYER) {	70	if (op->env && op->env->type == PLAYER) {
71	esrv_send_item (op->env, op);	71	esrv_send_item (op->env, op);
72	}	72	}
73	}	73	}
74	}	74	}
75		75
76		76
77		77
…		…
90	break;	90	break;
91	}	91	}
92	} else	92	} else
93	mt = name_to_material(op->materialname);	93	mt = name_to_material(op->materialname);
94	if (mt == NULL)	94	if (mt == NULL)
95	return TRUE;	95	return TRUE;
96	roll = rndm(1, 20);	96	roll = rndm(1, 20);
97		97
98	/* the attacktypes have no meaning for object saves	98	/* the attacktypes have no meaning for object saves
99	* If the type is only magic, don't adjust type - basically, if	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	100	* pure magic is hitting an object, it should save. However, if it
…		…
102	* magic type, and instead let the fire, cold, or whatever component	102	* magic type, and instead let the fire, cold, or whatever component
103	* destroy the item. Otherwise, you get the case of poisoncloud	103	* destroy the item. Otherwise, you get the case of poisoncloud
104	* destroying objects because it has magic attacktype.	104	* destroying objects because it has magic attacktype.
105	*/	105	*/
106	if (type != AT_MAGIC)	106	if (type != AT_MAGIC)
107	type &= ~(AT_CONFUSION|AT_DRAIN|AT_GHOSTHIT|AT_POISON|AT_SLOW|	107	type &= ~(AT_CONFUSION|AT_DRAIN|AT_GHOSTHIT|AT_POISON|AT_SLOW|
108	AT_PARALYZE|AT_TURN_UNDEAD|AT_FEAR|AT_DEPLETE|AT_DEATH|	108	AT_PARALYZE|AT_TURN_UNDEAD|AT_FEAR|AT_DEPLETE|AT_DEATH|
109	AT_COUNTERSPELL|AT_HOLYWORD|AT_BLIND|AT_LIFE_STEALING|	109	AT_COUNTERSPELL|AT_HOLYWORD|AT_BLIND|AT_LIFE_STEALING|
110	AT_MAGIC);	110	AT_MAGIC);
111		111
112	if (type == 0)	112	if (type == 0)
113	return TRUE;	113	return TRUE;
114	if (roll == 20)	114	if (roll == 20)
115	return TRUE;	115	return TRUE;
116	if (roll == 1)	116	if (roll == 1)
117	return FALSE;	117	return FALSE;
118		118
119	for (number=0; number < NROFATTACKS; number++) {	119	for (number=0; number < NROFATTACKS; number++) {
120	i = 1<<number;	120	i = 1<<number;
121	if (!(i&type))	121	if (!(i&type))
122	continue;	122	continue;
123	attacks++;	123	attacks++;
124	if (op->resist[number] == 100)	124	if (op->resist[number] == 100)
125	saves++;	125	saves++;
126	else if (roll >= mt->save[number] - op->magic - op->resist[number]/100)	126	else if (roll >= mt->save[number] - op->magic - op->resist[number]/100)
127	saves++;	127	saves++;
128	else if ((20-mt->save[number])/3 > originator->stats.dam)	128	else if ((20-mt->save[number])/3 > originator->stats.dam)
129	saves++;	129	saves++;
130	}	130	}
131		131
132	if (saves==attacks || attacks==0)	132	if (saves==attacks || attacks==0)
133	return TRUE;	133	return TRUE;
134	if ((saves==0) || (rndm(1, attacks) > saves))	134	if ((saves==0) || (rndm(1, attacks) > saves))
135	return FALSE;	135	return FALSE;
136	return TRUE;	136	return TRUE;
137	}	137	}
138		138
139	/* This function calls did_make_save_item. It then performs the	139	/* This function calls did_make_save_item. It then performs the
140	* appropriate actions to the item (such as burning the item up,	140	* appropriate actions to the item (such as burning the item up,
…		…
143		143
144	void save_throw_object (object *op, int type, object *originator)	144	void save_throw_object (object *op, int type, object *originator)
145	{	145	{
146	if ( ! did_make_save_item (op, type,originator))	146	if ( ! did_make_save_item (op, type,originator))
147	{	147	{
148	object *env=op->env;	148	object *env=op->env;
149	int x=op->x,y=op->y;	149	int x=op->x,y=op->y;
150	mapstruct *m=op->map;	150	mapstruct *m=op->map;
151		151
152	op = stop_item (op);	152	op = stop_item (op);
153	if (op == NULL)	153	if (op == NULL)
154	return;	154	return;
155		155
156	/* Hacked the following so that type LIGHTER will work.	156	/* Hacked the following so that type LIGHTER will work.
157	* Also, objects which are potenital "lights" that are hit by	157	* Also, objects which are potenital "lights" that are hit by
158	* flame/elect attacks will be set to glow. "lights" are any	158	* flame/elect attacks will be set to glow. "lights" are any
159	* object with +/- glow_radius and an "other_arch" to change to.	159	* object with +/- glow_radius and an "other_arch" to change to.
160	* (and please note that we cant fail our save and reach this	160	* (and please note that we cant fail our save and reach this
161	* function if the object doesnt contain a material that can burn.	161	* function if the object doesnt contain a material that can burn.
162	* So forget lighting magical swords on fire with this!) -b.t.	162	* So forget lighting magical swords on fire with this!) -b.t.
163	*/	163	*/
164	if(type&(AT_FIRE|AT_ELECTRICITY)	164	if(type&(AT_FIRE|AT_ELECTRICITY)
165	&&op->other_arch&&QUERY_FLAG(op, FLAG_IS_LIGHTABLE)) {	165	&&op->other_arch&&QUERY_FLAG(op, FLAG_IS_LIGHTABLE)) {
166	const char *arch=op->other_arch->name;	166	const char *arch=op->other_arch->name;
167		167
168	op = decrease_ob_nr (op, 1);	168	op = decrease_ob_nr (op, 1);
169	if (op)	169	if (op)
170	fix_stopped_item (op, m, originator);	170	fix_stopped_item (op, m, originator);
171	if((op = get_archetype(arch))!=NULL) {	171	if((op = get_archetype(arch))!=NULL) {
172	if(env) {	172	if(env) {
173	op->x=env->x,op->y=env->y;	173	op->x=env->x,op->y=env->y;
174	insert_ob_in_ob(op,env);	174	insert_ob_in_ob(op,env);
175	if (env->contr)	175	if (env->contr)
176	esrv_send_item(env, op);	176	esrv_send_item(env, op);
177	} else {	177	} else {
178	op->x=x,op->y=y;	178	op->x=x,op->y=y;
179	insert_ob_in_map(op,m,originator,0);	179	insert_ob_in_map(op,m,originator,0);
180	}	180	}
181	}	181	}
182	return;	182	return;
183	}	183	}
184	if(type&AT_CANCELLATION) { /* Cancellation. */	184	if(type&AT_CANCELLATION) { /* Cancellation. */
185	cancellation(op);	185	cancellation(op);
186	fix_stopped_item (op, m, originator);	186	fix_stopped_item (op, m, originator);
187	return;	187	return;
188	}	188	}
189	if(op->nrof>1) {	189	if(op->nrof>1) {
190	op = decrease_ob_nr(op,rndm(0, op->nrof-1));	190	op = decrease_ob_nr(op,rndm(0, op->nrof-1));
191	if (op)	191	if (op)
192	fix_stopped_item (op, m, originator);	192	fix_stopped_item (op, m, originator);
193	} else {	193	} else {
194	if (op->env) {	194	if (op->env) {
195	object *tmp= is_player_inv(op->env);	195	object *tmp= is_player_inv(op->env);
196		196
197	if (tmp) {	197	if (tmp) {
198	esrv_del_item(tmp->contr, op->count);	198	esrv_del_item(tmp->contr, op->count);
199	}	199	}
200	}	200	}
201	if ( ! QUERY_FLAG (op, FLAG_REMOVED))	201	if ( ! QUERY_FLAG (op, FLAG_REMOVED))
202	remove_ob(op);	202	remove_ob(op);
203	free_object(op);	203	free_object(op);
204	}	204	}
205	if(type&(AT_FIRE|AT_ELECTRICITY)) {	205	if(type&(AT_FIRE|AT_ELECTRICITY)) {
206	if(env) {	206	if(env) {
207	op=get_archetype("burnout");	207	op=get_archetype("burnout");
208	op->x=env->x,op->y=env->y;	208	op->x=env->x,op->y=env->y;
209	insert_ob_in_ob(op,env);	209	insert_ob_in_ob(op,env);
210	} else {	210	} else {
211	replace_insert_ob_in_map("burnout",originator);	211	replace_insert_ob_in_map("burnout",originator);
		212	}
212	}	213	}
213	}	214	return;
214	return;
215	}	215	}
216	/* The value of 50 is arbitrary. */	216	/* The value of 50 is arbitrary. */
217	if(type&AT_COLD &&(op->resist[ATNR_COLD]<50) &&	217	if(type&AT_COLD &&(op->resist[ATNR_COLD]<50) &&
218	!QUERY_FLAG(op,FLAG_NO_PICK)&&(RANDOM()&2)) {	218	!QUERY_FLAG(op,FLAG_NO_PICK)&&(RANDOM()&2)) {
219	object *tmp;	219	object *tmp;
…		…
222	return;	222	return;
223	op = stop_item (op);	223	op = stop_item (op);
224	if (op == NULL)	224	if (op == NULL)
225	return;	225	return;
226	if ((tmp = present_arch(at,op->map,op->x,op->y)) == NULL) {	226	if ((tmp = present_arch(at,op->map,op->x,op->y)) == NULL) {
227	tmp = arch_to_object(at);	227	tmp = arch_to_object(at);
228	tmp->x=op->x,tmp->y=op->y;	228	tmp->x=op->x,tmp->y=op->y;
229	/* This was in the old (pre new movement code) -	229	/* This was in the old (pre new movement code) -
230	* icecubes have slow_move set to 1 - don't want	230	* icecubes have slow_move set to 1 - don't want
231	* that for ones we create.	231	* that for ones we create.
232	*/	232	*/
233	tmp->move_slow_penalty=0;	233	tmp->move_slow_penalty=0;
234	tmp->move_slow=0;	234	tmp->move_slow=0;
235	insert_ob_in_map(tmp,op->map,originator,0);	235	insert_ob_in_map(tmp,op->map,originator,0);
236	}	236	}
237	if ( ! QUERY_FLAG (op, FLAG_REMOVED))	237	if ( ! QUERY_FLAG (op, FLAG_REMOVED))
238	remove_ob(op);	238	remove_ob(op);
239	(void) insert_ob_in_ob(op,tmp);	239	(void) insert_ob_in_ob(op,tmp);
240	return;	240	return;
…		…
255	int retflag=0; /* added this flag.. will return 1 if it hits a monster */	255	int retflag=0; /* added this flag.. will return 1 if it hits a monster */
256		256
257	tag_t op_tag, next_tag=0;	257	tag_t op_tag, next_tag=0;
258		258
259	if (QUERY_FLAG (op, FLAG_FREED)) {	259	if (QUERY_FLAG (op, FLAG_FREED)) {
260	LOG (llevError, "BUG: hit_map(): free object\n");	260	LOG (llevError, "BUG: hit_map(): free object\n");
261	return 0;	261	return 0;
262	}	262	}
263		263
264	if (QUERY_FLAG (op, FLAG_REMOVED) || op->env != NULL) {	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",	265	LOG (llevError, "BUG: hit_map(): hitter (arch %s, name %s) not on a map\n",
266	op->arch->name, op->name);	266	op->arch->name, op->name);
267	return 0;	267	return 0;
268	}	268	}
269		269
270	if ( ! op->map) {	270	if ( ! op->map) {
271	LOG (llevError,"BUG: hit_map(): %s has no map\n", op->name);	271	LOG (llevError,"BUG: hit_map(): %s has no map\n", op->name);
272	return 0;	272	return 0;
273	}	273	}
274		274
275	if (op->head) op=op->head;	275	if (op->head) op=op->head;
276		276
277	op_tag = op->count;	277	op_tag = op->count;
278		278
279	map = op->map;	279	map = op->map;
280	x = op->x + freearr_x[dir];	280	x = op->x + freearr_x[dir];
281	y = op->y + freearr_y[dir];	281	y = op->y + freearr_y[dir];
282	if (get_map_flags(map, &map, x, y, &x, &y) & P_OUT_OF_MAP)	282	if (get_map_flags(map, &map, x, y, &x, &y) & P_OUT_OF_MAP)
283	return 0;	283	return 0;
284		284
285	/* peterm: a few special cases for special attacktypes --counterspell	285	/* peterm: a few special cases for special attacktypes --counterspell
286	* must be out here because it strikes things which are not alive	286	* must be out here because it strikes things which are not alive
287	*/	287	*/
288		288
289	if (type & AT_COUNTERSPELL) {	289	if (type & AT_COUNTERSPELL) {
290	counterspell(op,dir); /* see spell_effect.c */	290	counterspell(op,dir); /* see spell_effect.c */
291		291
292	/* If the only attacktype is counterspell or magic, don't need	292	/* If the only attacktype is counterspell or magic, don't need
293	* to do any further processing.	293	* to do any further processing.
294	*/	294	*/
295	if(!(type & ~(AT_COUNTERSPELL|AT_MAGIC))){	295	if(!(type & ~(AT_COUNTERSPELL|AT_MAGIC))){
296	return 0;	296	return 0;
297	}	297	}
298	type &= ~AT_COUNTERSPELL;	298	type &= ~AT_COUNTERSPELL;
299	}	299	}
300		300
301	if(type & AT_CHAOS){	301	if(type & AT_CHAOS){
302	shuffle_attack(op,1); /*1 flag tells it to change the face */	302	shuffle_attack(op,1); /*1 flag tells it to change the face */
303	update_object(op,UP_OBJ_FACE);	303	update_object(op,UP_OBJ_FACE);
304	type &= ~AT_CHAOS;	304	type &= ~AT_CHAOS;
305	}	305	}
306		306
307	next = get_map_ob (map, x, y);	307	next = get_map_ob (map, x, y);
308	if (next)	308	if (next)
309	next_tag = next->count;	309	next_tag = next->count;
310		310
311	while (next) {	311	while (next) {
312	if (was_destroyed (next, next_tag)) {	312	if (was_destroyed (next, next_tag)) {
313	/* There may still be objects that were above 'next', but there is no	313	/* There may still be objects that were above 'next', but there is no
314	* simple way to find out short of copying all object references and	314	* simple way to find out short of copying all object references and
315	* tags into a temporary array before we start processing the first	315	* tags into a temporary array before we start processing the first
316	* object. That's why we just abort.	316	* object. That's why we just abort.
317	*	317	*
318	* This happens whenever attack spells (like fire) hit a pile	318	* This happens whenever attack spells (like fire) hit a pile
319	* of objects. This is not a bug - nor an error. The errormessage	319	* of objects. This is not a bug - nor an error. The errormessage
320	* below was spamming the logs for absolutely no reason.	320	* below was spamming the logs for absolutely no reason.
321	*/	321	*/
322	/* LOG (llevDebug, "hit_map(): next object destroyed\n"); */	322	/* LOG (llevDebug, "hit_map(): next object destroyed\n"); */
323	break;	323	break;
324	}	324	}
325	tmp = next;	325	tmp = next;
326	next = tmp->above;	326	next = tmp->above;
327	if (next)	327	if (next)
328	next_tag = next->count;	328	next_tag = next->count;
329		329
330	if (QUERY_FLAG (tmp, FLAG_FREED)) {	330	if (QUERY_FLAG (tmp, FLAG_FREED)) {
331	LOG (llevError, "BUG: hit_map(): found freed object\n");	331	LOG (llevError, "BUG: hit_map(): found freed object\n");
332	break;	332	break;
333	}	333	}
334		334
335	/* Something could have happened to 'tmp' while 'tmp->below' was processed.	335	/* Something could have happened to 'tmp' while 'tmp->below' was processed.
336	* For example, 'tmp' was put in an icecube.	336	* For example, 'tmp' was put in an icecube.
337	* This is one of the few cases where on_same_map should not be used.	337	* This is one of the few cases where on_same_map should not be used.
338	*/	338	*/
339	if (tmp->map != map || tmp->x != x || tmp->y != y)	339	if (tmp->map != map || tmp->x != x || tmp->y != y)
340	continue;	340	continue;
341		341
342	if (QUERY_FLAG (tmp, FLAG_ALIVE)) {	342	if (QUERY_FLAG (tmp, FLAG_ALIVE)) {
343	hit_player(tmp,op->stats.dam,op,type,full_hit);	343	hit_player(tmp,op->stats.dam,op,type,full_hit);
344	retflag |=1;	344	retflag |=1;
345	if (was_destroyed (op, op_tag))	345	if (was_destroyed (op, op_tag))
346	break;	346	break;
347	}	347	}
348	/* Here we are potentially destroying an object. If the object has	348	/* Here we are potentially destroying an object. If the object has
349	* NO_PASS set, it is also immune - you can't destroy walls. Note	349	* NO_PASS set, it is also immune - you can't destroy walls. Note
350	* that weak walls have is_alive set, which prevent objects from	350	* that weak walls have is_alive set, which prevent objects from
351	* passing over/through them. We don't care what type of movement	351	* passing over/through them. We don't care what type of movement
352	* the wall blocks - if it blocks any type of movement, can't be	352	* the wall blocks - if it blocks any type of movement, can't be
353	* destroyed right now.	353	* destroyed right now.
354	*/	354	*/
355	else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 &&	355	else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 &&
356	!tmp->move_block) {	356	!tmp->move_block) {
357	save_throw_object(tmp,type,op);	357	save_throw_object(tmp,type,op);
358	if (was_destroyed (op, op_tag))	358	if (was_destroyed (op, op_tag))
359	break;	359	break;
360	}	360	}
361	}	361	}
362	return 0;	362	return 0;
363	}	363	}
364		364
365	void attack_message(int dam, int type, object *op, object *hitter) {	365	void attack_message(int dam, int type, object *op, object *hitter) {
…		…
372	* a player might have. For example, fire, electric, cold, etc	372	* a player might have. For example, fire, electric, cold, etc
373	* [garbled 20010919]	373	* [garbled 20010919]
374	*/	374	*/
375		375
376	if (dam == 9998 && op->type == DOOR) {	376	if (dam == 9998 && op->type == DOOR) {
377	sprintf(buf1, "unlock %s", op->name);	377	sprintf(buf1, "unlock %s", op->name);
378	sprintf(buf2, " unlocks");	378	sprintf(buf2, " unlocks");
379	found++;	379	found++;
380	}	380	}
381	if(dam<0) {	381	if(dam<0) {
382	sprintf(buf1, "hit %s", op->name);	382	sprintf(buf1, "hit %s", op->name);
383	sprintf(buf2, " hits");	383	sprintf(buf2, " hits");
384	found++;	384	found++;
385	} else if(dam==0) {	385	} else if(dam==0) {
386	sprintf(buf1, "missed %s", op->name);	386	sprintf(buf1, "missed %s", op->name);
387	sprintf(buf2, " misses");	387	sprintf(buf2, " misses");
388	found++;	388	found++;
389	} else if ((hitter->type == DISEASE || hitter->type == SYMPTOM ||	389	} else if ((hitter->type == DISEASE || hitter->type == SYMPTOM ||
390	hitter->type == POISONING ||	390	hitter->type == POISONING ||
391	(type & AT_POISON && IS_LIVE(op))) && !found) {	391	(type & AT_POISON && IS_LIVE(op))) && !found) {
392	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1;	392	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1;
393	i++)	393	i++)
394	if (dam < attack_mess[ATM_SUFFER][i].level	394	if (dam < attack_mess[ATM_SUFFER][i].level
395	|| attack_mess[ATM_SUFFER][i+1].level == -1) {	395	|| attack_mess[ATM_SUFFER][i+1].level == -1) {
396	sprintf(buf1, "%s %s%s", attack_mess[ATM_SUFFER][i].buf1,	396	sprintf(buf1, "%s %s%s", attack_mess[ATM_SUFFER][i].buf1,
397	op->name, attack_mess[ATM_SUFFER][i].buf2);	397	op->name, attack_mess[ATM_SUFFER][i].buf2);
398	strcpy (buf2, attack_mess[ATM_SUFFER][i].buf3);	398	strcpy (buf2, attack_mess[ATM_SUFFER][i].buf3);
399	found++;	399	found++;
400	break;	400	break;
401	}	401	}
402	} else if (op->type == DOOR && !found) {	402	} else if (op->type == DOOR && !found) {
403	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_DOOR][i].level != -1;	403	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_DOOR][i].level != -1;
404	i++)	404	i++)
405	if (dam < attack_mess[ATM_DOOR][i].level	405	if (dam < attack_mess[ATM_DOOR][i].level
406	|| attack_mess[ATM_DOOR][i+1].level == -1) {	406	|| attack_mess[ATM_DOOR][i+1].level == -1) {
407	sprintf(buf1, "%s %s%s", attack_mess[ATM_DOOR][i].buf1,	407	sprintf(buf1, "%s %s%s", attack_mess[ATM_DOOR][i].buf1,
408	op->name, attack_mess[ATM_DOOR][i].buf2);	408	op->name, attack_mess[ATM_DOOR][i].buf2);
409	strcpy (buf2, attack_mess[ATM_DOOR][i].buf3);	409	strcpy (buf2, attack_mess[ATM_DOOR][i].buf3);
410	found++;	410	found++;
411	break;	411	break;
412	}	412	}
413	} else if (hitter->type == PLAYER && IS_LIVE(op)) {	413	} else if (hitter->type == PLAYER && IS_LIVE(op)) {
414	if (USING_SKILL(hitter, SK_KARATE)) {	414	if (USING_SKILL(hitter, SK_KARATE)) {
415	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1;	415	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1;
416	i++)	416	i++)
417	if (dam < attack_mess[ATM_KARATE][i].level	417	if (dam < attack_mess[ATM_KARATE][i].level
418	|| attack_mess[ATM_KARATE][i+1].level == -1) {	418	|| attack_mess[ATM_KARATE][i+1].level == -1) {
419	sprintf(buf1, "%s %s%s", attack_mess[ATM_KARATE][i].buf1,	419	sprintf(buf1, "%s %s%s", attack_mess[ATM_KARATE][i].buf1,
420	op->name, attack_mess[ATM_KARATE][i].buf2);	420	op->name, attack_mess[ATM_KARATE][i].buf2);
421	strcpy (buf2, attack_mess[ATM_KARATE][i].buf3);	421	strcpy (buf2, attack_mess[ATM_KARATE][i].buf3);
422	found++;	422	found++;
423	break;	423	break;
424	}	424	}
425	} else if (USING_SKILL(hitter, SK_CLAWING)) {	425	} else if (USING_SKILL(hitter, SK_CLAWING)) {
426	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_CLAW][i].level != -1;	426	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_CLAW][i].level != -1;
427	i++)	427	i++)
428	if (dam < attack_mess[ATM_CLAW][i].level	428	if (dam < attack_mess[ATM_CLAW][i].level
429	|| attack_mess[ATM_CLAW][i+1].level == -1) {	429	|| attack_mess[ATM_CLAW][i+1].level == -1) {
430	sprintf(buf1, "%s %s%s", attack_mess[ATM_CLAW][i].buf1,	430	sprintf(buf1, "%s %s%s", attack_mess[ATM_CLAW][i].buf1,
431	op->name, attack_mess[ATM_CLAW][i].buf2);	431	op->name, attack_mess[ATM_CLAW][i].buf2);
432	strcpy (buf2, attack_mess[ATM_CLAW][i].buf3);	432	strcpy (buf2, attack_mess[ATM_CLAW][i].buf3);
433	found++;	433	found++;
434	break;	434	break;
435	}	435	}
436	} else if (USING_SKILL(hitter, SK_PUNCHING)) {	436	} else if (USING_SKILL(hitter, SK_PUNCHING)) {
437	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_PUNCH][i].level != -1;	437	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_PUNCH][i].level != -1;
438	i++)	438	i++)
439	if (dam < attack_mess[ATM_PUNCH][i].level	439	if (dam < attack_mess[ATM_PUNCH][i].level
440	|| attack_mess[ATM_PUNCH][i+1].level == -1) {	440	|| attack_mess[ATM_PUNCH][i+1].level == -1) {
441	sprintf(buf1, "%s %s%s", attack_mess[ATM_PUNCH][i].buf1,	441	sprintf(buf1, "%s %s%s", attack_mess[ATM_PUNCH][i].buf1,
442	op->name, attack_mess[ATM_PUNCH][i].buf2);	442	op->name, attack_mess[ATM_PUNCH][i].buf2);
443	strcpy (buf2, attack_mess[ATM_PUNCH][i].buf3);	443	strcpy (buf2, attack_mess[ATM_PUNCH][i].buf3);
444	found++;	444	found++;
445	break;	445	break;
		446	}
446	}	447	}
447	}
448	}	448	}
449	if (found) {	449	if (found) {
450	/* done */	450	/* done */
451	} else if (IS_ARROW(hitter) && (type == AT_PHYSICAL || type == AT_MAGIC)) {	451	} else if (IS_ARROW(hitter) && (type == AT_PHYSICAL || type == AT_MAGIC)) {
452	sprintf(buf1, "hit"); /* just in case */	452	sprintf(buf1, "hit"); /* just in case */
453	for (i=0; i < MAXATTACKMESS; i++)	453	for (i=0; i < MAXATTACKMESS; i++)
454	if (dam < attack_mess[ATM_ARROW][i].level	454	if (dam < attack_mess[ATM_ARROW][i].level
455	|| attack_mess[ATM_ARROW][i+1].level == -1) {	455	|| attack_mess[ATM_ARROW][i+1].level == -1) {
456	strcpy (buf2, attack_mess[ATM_ARROW][i].buf3);	456	strcpy (buf2, attack_mess[ATM_ARROW][i].buf3);
457	found++;	457	found++;
458	break;	458	break;
459	}	459	}
460	} else if (type & AT_DRAIN && IS_LIVE(op)) {	460	} else if (type & AT_DRAIN && IS_LIVE(op)) {
461	/* drain is first, because some items have multiple attypes */	461	/* drain is first, because some items have multiple attypes */
462	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1;	462	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1;
463	i++)	463	i++)
464	if (dam < attack_mess[ATM_DRAIN][i].level	464	if (dam < attack_mess[ATM_DRAIN][i].level
465	|| attack_mess[ATM_DRAIN][i+1].level == -1) {	465	|| attack_mess[ATM_DRAIN][i+1].level == -1) {
466	sprintf(buf1, "%s %s%s", attack_mess[ATM_DRAIN][i].buf1,	466	sprintf(buf1, "%s %s%s", attack_mess[ATM_DRAIN][i].buf1,
467	op->name, attack_mess[ATM_DRAIN][i].buf2);	467	op->name, attack_mess[ATM_DRAIN][i].buf2);
468	strcpy (buf2, attack_mess[ATM_DRAIN][i].buf3);	468	strcpy (buf2, attack_mess[ATM_DRAIN][i].buf3);
469	found++;	469	found++;
470	break;	470	break;
471	}	471	}
472	} else if (type & AT_ELECTRICITY && IS_LIVE(op)) {	472	} else if (type & AT_ELECTRICITY && IS_LIVE(op)) {
473	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1;	473	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1;
474	i++)	474	i++)
475	if (dam < attack_mess[ATM_ELEC][i].level	475	if (dam < attack_mess[ATM_ELEC][i].level
476	|| attack_mess[ATM_ELEC][i+1].level == -1) {	476	|| attack_mess[ATM_ELEC][i+1].level == -1) {
477	sprintf(buf1, "%s %s%s", attack_mess[ATM_ELEC][i].buf1,	477	sprintf(buf1, "%s %s%s", attack_mess[ATM_ELEC][i].buf1,
478	op->name, attack_mess[ATM_ELEC][i].buf2);	478	op->name, attack_mess[ATM_ELEC][i].buf2);
479	strcpy (buf2, attack_mess[ATM_ELEC][i].buf3);	479	strcpy (buf2, attack_mess[ATM_ELEC][i].buf3);
480	found++;	480	found++;
481	break;	481	break;
482	}	482	}
483	} else if (type & AT_COLD && IS_LIVE(op)) {	483	} else if (type & AT_COLD && IS_LIVE(op)) {
484	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1;	484	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1;
485	i++)	485	i++)
486	if (dam < attack_mess[ATM_COLD][i].level	486	if (dam < attack_mess[ATM_COLD][i].level
487	|| attack_mess[ATM_COLD][i+1].level == -1) {	487	|| attack_mess[ATM_COLD][i+1].level == -1) {
488	sprintf(buf1, "%s %s%s", attack_mess[ATM_COLD][i].buf1,	488	sprintf(buf1, "%s %s%s", attack_mess[ATM_COLD][i].buf1,
489	op->name, attack_mess[ATM_COLD][i].buf2);	489	op->name, attack_mess[ATM_COLD][i].buf2);
490	strcpy (buf2, attack_mess[ATM_COLD][i].buf3);	490	strcpy (buf2, attack_mess[ATM_COLD][i].buf3);
491	found++;	491	found++;
492	break;	492	break;
493	}	493	}
494	} else if (type & AT_FIRE) {	494	} else if (type & AT_FIRE) {
495	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_FIRE][i].level != -1;	495	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_FIRE][i].level != -1;
496	i++)	496	i++)
497	if (dam < attack_mess[ATM_FIRE][i].level	497	if (dam < attack_mess[ATM_FIRE][i].level
498	|| attack_mess[ATM_FIRE][i+1].level == -1) {	498	|| attack_mess[ATM_FIRE][i+1].level == -1) {
499	sprintf(buf1, "%s %s%s", attack_mess[ATM_FIRE][i].buf1,	499	sprintf(buf1, "%s %s%s", attack_mess[ATM_FIRE][i].buf1,
500	op->name, attack_mess[ATM_FIRE][i].buf2);	500	op->name, attack_mess[ATM_FIRE][i].buf2);
501	strcpy (buf2, attack_mess[ATM_FIRE][i].buf3);	501	strcpy (buf2, attack_mess[ATM_FIRE][i].buf3);
502	found++;	502	found++;
503	break;	503	break;
504	}	504	}
505	} else if (hitter->current_weapon != NULL) {	505	} else if (hitter->current_weapon != NULL) {
506	int mtype;	506	int mtype;
507	switch (hitter->current_weapon->weapontype) {	507	switch (hitter->current_weapon->weapontype) {
508	case WEAP_HIT: mtype = ATM_BASIC; break;	508	case WEAP_HIT: mtype = ATM_BASIC; break;
509	case WEAP_SLASH: mtype = ATM_SLASH; break;	509	case WEAP_SLASH: mtype = ATM_SLASH; break;
510	case WEAP_PIERCE: mtype = ATM_PIERCE; break;	510	case WEAP_PIERCE: mtype = ATM_PIERCE; break;
511	case WEAP_CLEAVE: mtype = ATM_CLEAVE; break;	511	case WEAP_CLEAVE: mtype = ATM_CLEAVE; break;
512	case WEAP_SLICE: mtype = ATM_SLICE; break;	512	case WEAP_SLICE: mtype = ATM_SLICE; break;
513	case WEAP_STAB: mtype = ATM_STAB; break;	513	case WEAP_STAB: mtype = ATM_STAB; break;
514	case WEAP_WHIP: mtype = ATM_WHIP; break;	514	case WEAP_WHIP: mtype = ATM_WHIP; break;
515	case WEAP_CRUSH: mtype = ATM_CRUSH; break;	515	case WEAP_CRUSH: mtype = ATM_CRUSH; break;
516	case WEAP_BLUD: mtype = ATM_BLUD; break;	516	case WEAP_BLUD: mtype = ATM_BLUD; break;
517	default: mtype = ATM_BASIC; break;	517	default: mtype = ATM_BASIC; break;
518	}	518	}
519	for (i=0; i < MAXATTACKMESS && attack_mess[mtype][i].level != -1;	519	for (i=0; i < MAXATTACKMESS && attack_mess[mtype][i].level != -1;
520	i++)	520	i++)
521	if (dam < attack_mess[mtype][i].level	521	if (dam < attack_mess[mtype][i].level
522	|| attack_mess[mtype][i+1].level == -1) {	522	|| attack_mess[mtype][i+1].level == -1) {
523	sprintf(buf1, "%s %s%s", attack_mess[mtype][i].buf1,	523	sprintf(buf1, "%s %s%s", attack_mess[mtype][i].buf1,
524	op->name, attack_mess[mtype][i].buf2);	524	op->name, attack_mess[mtype][i].buf2);
525	strcpy (buf2, attack_mess[mtype][i].buf3);	525	strcpy (buf2, attack_mess[mtype][i].buf3);
526	found++;	526	found++;
527	break;	527	break;
528	}	528	}
529	} else {	529	} else {
530	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_BASIC][i].level != -1;	530	for (i=0; i < MAXATTACKMESS && attack_mess[ATM_BASIC][i].level != -1;
531	i++)	531	i++)
532	if (dam < attack_mess[ATM_BASIC][i].level	532	if (dam < attack_mess[ATM_BASIC][i].level
533	|| attack_mess[ATM_BASIC][i+1].level == -1) {	533	|| attack_mess[ATM_BASIC][i+1].level == -1) {
534	sprintf(buf1, "%s %s%s", attack_mess[ATM_BASIC][i].buf1,	534	sprintf(buf1, "%s %s%s", attack_mess[ATM_BASIC][i].buf1,
535	op->name, attack_mess[ATM_BASIC][i].buf2);	535	op->name, attack_mess[ATM_BASIC][i].buf2);
536	strcpy (buf2, attack_mess[ATM_BASIC][i].buf3);	536	strcpy (buf2, attack_mess[ATM_BASIC][i].buf3);
537	found++;	537	found++;
538	break;	538	break;
539	}	539	}
540	}	540	}
541		541
542	if (!found) {	542	if (!found) {
543	strcpy (buf1, "hit");	543	strcpy (buf1, "hit");
544	strcpy (buf2, " hits");	544	strcpy (buf2, " hits");
545	}	545	}
546		546
547	/* bail out if a monster is casting spells */	547	/* bail out if a monster is casting spells */
548	if (!(hitter->type == PLAYER ||	548	if (!(hitter->type == PLAYER ||
549	(get_owner(hitter) != NULL && hitter->owner->type == PLAYER)))	549	(get_owner(hitter) != NULL && hitter->owner->type == PLAYER)))
550	return;	550	return;
551		551
552	/* scale down magic considerably. */	552	/* scale down magic considerably. */
553	if (type & AT_MAGIC && rndm(0, 5))	553	if (type & AT_MAGIC && rndm(0, 5))
554	return;	554	return;
555		555
556	/* Did a player hurt another player? Inform both! */	556	/* Did a player hurt another player? Inform both! */
557	if(op->type==PLAYER &&	557	if(op->type==PLAYER &&
558	(get_owner(hitter)==NULL?hitter->type:hitter->owner->type)==PLAYER) {	558	(get_owner(hitter)==NULL?hitter->type:hitter->owner->type)==PLAYER) {
559	if(get_owner(hitter)!=NULL)	559	if(get_owner(hitter)!=NULL)
560	sprintf(buf,"%s's %s%s you.",	560	sprintf(buf,"%s's %s%s you.",
561	hitter->owner->name, hitter->name, buf2);	561	hitter->owner->name, hitter->name, buf2);
562	else {	562	else {
563	sprintf(buf,"%s%s you.",hitter->name, buf2);	563	sprintf(buf,"%s%s you.",hitter->name, buf2);
564	if (dam != 0) {	564	if (dam != 0) {
565	if (dam < 10)	565	if (dam < 10)
566	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT1,0,0);	566	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT1,0,0);
567	else if (dam < 20)	567	else if (dam < 20)
568	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT2,0,0);	568	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT2,0,0);
569	else	569	else
570	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT3,0,0);	570	play_sound_player_only(op->contr, SOUND_PLAYER_IS_HIT3,0,0);
571	}	571	}
572	}	572	}
573	new_draw_info(NDI_BLACK, 0,op,buf);	573	new_draw_info(NDI_BLACK, 0,op,buf);
574	} /* end of player hitting player */	574	} /* end of player hitting player */
575		575
576	if(hitter->type==PLAYER) {	576	if(hitter->type==PLAYER) {
577	sprintf(buf,"You %s.",buf1);	577	sprintf(buf,"You %s.",buf1);
578	if (dam != 0) {	578	if (dam != 0) {
579	if (dam < 10)	579	if (dam < 10)
580	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS1,0,0);	580	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS1,0,0);
581	else if (dam < 20)	581	else if (dam < 20)
582	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS2,0,0);	582	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS2,0,0);
583	else	583	else
584	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS3,0,0);	584	play_sound_player_only(hitter->contr, SOUND_PLAYER_HITS3,0,0);
585	}	585	}
586	new_draw_info(NDI_BLACK, 0, hitter, buf);	586	new_draw_info(NDI_BLACK, 0, hitter, buf);
587	} else if(get_owner(hitter)!=NULL&&hitter->owner->type==PLAYER) {	587	} else if(get_owner(hitter)!=NULL&&hitter->owner->type==PLAYER) {
588	/* look for stacked spells and start reducing the message chances */	588	/* look for stacked spells and start reducing the message chances */
589	if (hitter->type == SPELL_EFFECT &&	589	if (hitter->type == SPELL_EFFECT &&
590	(hitter->subtype == SP_EXPLOSION ||	590	(hitter->subtype == SP_EXPLOSION ||
591	hitter->subtype == SP_BULLET ||	591	hitter->subtype == SP_BULLET ||
592	hitter->subtype == SP_CONE)) {	592	hitter->subtype == SP_CONE)) {
593	i=4;	593	i=4;
594	map = hitter->map;	594	map = hitter->map;
595	if (out_of_map(map, hitter->x, hitter->y))	595	if (out_of_map(map, hitter->x, hitter->y))
596	return;	596	return;
597	next = get_map_ob(map, hitter->x, hitter->y);	597	next = get_map_ob(map, hitter->x, hitter->y);
598	if (next)	598	if (next)
599	while(next) {	599	while(next) {
600	if (next->type == SPELL_EFFECT &&	600	if (next->type == SPELL_EFFECT &&
601	(next->subtype == SP_EXPLOSION || next->subtype==SP_BULLET ||	601	(next->subtype == SP_EXPLOSION || next->subtype==SP_BULLET ||
602	next->subtype == SP_CONE))	602	next->subtype == SP_CONE))
603	i*=3;	603	i*=3;
604	tmp = next;	604	tmp = next;
605	next = tmp->above;	605	next = tmp->above;
606	}	606	}
607	if (i < 0)	607	if (i < 0)
608	return;	608	return;
609	if (rndm(0, i) != 0)	609	if (rndm(0, i) != 0)
610	return;	610	return;
611	} else if (rndm(0, 5) != 0)	611	} else if (rndm(0, 5) != 0)
612	return;	612	return;
613	sprintf(buf,"Your %s%s %s.", hitter->name, buf2, op->name);	613	sprintf(buf,"Your %s%s %s.", hitter->name, buf2, op->name);
614	play_sound_map(op->map, op->x, op->y, SOUND_PLAYER_HITS4);	614	play_sound_map(op->map, op->x, op->y, SOUND_PLAYER_HITS4);
615	new_draw_info(NDI_BLACK, 0, hitter->owner, buf);	615	new_draw_info(NDI_BLACK, 0, hitter->owner, buf);
616	}	616	}
617	}	617	}
618		618
619		619
620	static int get_attack_mode (object **target, object **hitter,	620	static int get_attack_mode (object **target, object **hitter,
621	int *simple_attack)	621	int *simple_attack)
622	{	622	{
623	if (QUERY_FLAG (*target, FLAG_FREED) || QUERY_FLAG (*hitter, FLAG_FREED)) {	623	if (QUERY_FLAG (*target, FLAG_FREED) || QUERY_FLAG (*hitter, FLAG_FREED)) {
624	LOG (llevError, "BUG: get_attack_mode(): freed object\n");	624	LOG (llevError, "BUG: get_attack_mode(): freed object\n");
625	return 1;	625	return 1;
626	}	626	}
…		…
663	}	663	}
664		664
665	static void thrown_item_effect (object *, object *);	665	static void thrown_item_effect (object *, object *);
666		666
667	static int attack_ob_simple (object *op, object *hitter, int base_dam,	667	static int attack_ob_simple (object *op, object *hitter, int base_dam,
668	int base_wc)	668	int base_wc)
669	{	669	{
670	int simple_attack, roll, dam=0;	670	int simple_attack, roll, dam=0;
671	uint32 type;	671	uint32 type;
672	const char *op_name = NULL;	672	const char *op_name = NULL;
673	tag_t op_tag, hitter_tag;	673	tag_t op_tag, hitter_tag;
…		…
690	* to avoid ever being hit by monsters.	690	* to avoid ever being hit by monsters.
691	*/	691	*/
692	if ( ! simple_attack && QUERY_FLAG (op, FLAG_MONSTER)	692	if ( ! simple_attack && QUERY_FLAG (op, FLAG_MONSTER)
693	&& op->speed_left > -(FABS(op->speed))*0.3)	693	&& op->speed_left > -(FABS(op->speed))*0.3)
694	{	694	{
695	/* Decrease speed BEFORE calling process_object. Otherwise, an	695	/* Decrease speed BEFORE calling process_object. Otherwise, an
696	* infinite loop occurs, with process_object calling move_monster,	696	* infinite loop occurs, with process_object calling move_monster,
697	* which then gets here again. By decreasing the speed before	697	* which then gets here again. By decreasing the speed before
698	* we call process_object, the 'if' statement above will fail.	698	* we call process_object, the 'if' statement above will fail.
699	*/	699	*/
700	op->speed_left--;	700	op->speed_left--;
701	process_object(op);	701	process_object(op);
702	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag)	702	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag)
703	|| abort_attack (op, hitter, simple_attack))	703	|| abort_attack (op, hitter, simple_attack))
704	goto error;	704	goto error;
705	}	705	}
706		706
707	add_refcount(op_name = op->name);	707	add_refcount(op_name = op->name);
708		708
709	roll=random_roll(1, 20, hitter, PREFER_HIGH);	709	roll=random_roll(1, 20, hitter, PREFER_HIGH);
…		…
712	if ( ! simple_attack)	712	if ( ! simple_attack)
713	roll += adj_attackroll(hitter,op);	713	roll += adj_attackroll(hitter,op);
714		714
715	/* See if we hit the creature */	715	/* See if we hit the creature */
716	if(roll==20 || op->stats.ac>=base_wc-roll) {	716	if(roll==20 || op->stats.ac>=base_wc-roll) {
717	int hitdam = base_dam;	717	int hitdam = base_dam;
718	if (settings.casting_time == TRUE) {	718	if (settings.casting_time == TRUE) {
719	if ((hitter->type == PLAYER)&&(hitter->casting_time > -1)){	719	if ((hitter->type == PLAYER)&&(hitter->casting_time > -1)){
720	hitter->casting_time = -1;	720	hitter->casting_time = -1;
721	new_draw_info(NDI_UNIQUE, 0,hitter,"You attacked and lost "	721	new_draw_info(NDI_UNIQUE, 0,hitter,"You attacked and lost "
722	"your spell!");	722	"your spell!");
723	}	723	}
724	if ((op->casting_time > -1)&&(hitdam > 0)){	724	if ((op->casting_time > -1)&&(hitdam > 0)){
725	op->casting_time = -1;	725	op->casting_time = -1;
726	if (op->type == PLAYER) {	726	if (op->type == PLAYER) {
727	new_draw_info(NDI_UNIQUE, 0,op,"You were hit and lost "	727	new_draw_info(NDI_UNIQUE, 0,op,"You were hit and lost "
728	"your spell!");	728	"your spell!");
729	new_draw_info_format(NDI_ALL|NDI_UNIQUE,5,NULL,	729	new_draw_info_format(NDI_ALL|NDI_UNIQUE,5,NULL,
730	"%s was hit by %s and lost a spell.",	730	"%s was hit by %s and lost a spell.",
731	op_name,hitter->name);	731	op_name,hitter->name);
732	}	732	}
733	}	733	}
734	}	734	}
735	if ( ! simple_attack)	735	if ( ! simple_attack)
736	{	736	{
737	/* If you hit something, the victim should *always* wake up.	737	/* If you hit something, the victim should *always* wake up.
738	* Before, invisible hitters could avoid doing this.	738	* Before, invisible hitters could avoid doing this.
739	* -b.t. */	739	* -b.t. */
740	if (QUERY_FLAG (op, FLAG_SLEEP))	740	if (QUERY_FLAG (op, FLAG_SLEEP))
…		…
765	|| was_destroyed (op, op_tag)	765	|| was_destroyed (op, op_tag)
766	|| abort_attack (op, hitter, simple_attack))	766	|| abort_attack (op, hitter, simple_attack))
767	goto leave;	767	goto leave;
768	}	768	}
769		769
770	/* Need to do at least 1 damage, otherwise there is no point	770	/* Need to do at least 1 damage, otherwise there is no point
771	* to go further and it will cause FPE's below.	771	* to go further and it will cause FPE's below.
772	*/	772	*/
773	if (hitdam<=0) hitdam=1;	773	if (hitdam<=0) hitdam=1;
774		774
775	type=hitter->attacktype;	775	type=hitter->attacktype;
776	if(!type) type=AT_PHYSICAL;	776	if(!type) type=AT_PHYSICAL;
777	/* Handle monsters that hit back */	777	/* Handle monsters that hit back */
778	if ( ! simple_attack && QUERY_FLAG (op, FLAG_HITBACK)	778	if ( ! simple_attack && QUERY_FLAG (op, FLAG_HITBACK)
779	&& QUERY_FLAG (hitter, FLAG_ALIVE))	779	&& QUERY_FLAG (hitter, FLAG_ALIVE))
780	{	780	{
781	if (op->attacktype & AT_ACID && hitter->type==PLAYER)	781	if (op->attacktype & AT_ACID && hitter->type==PLAYER)
782	new_draw_info(NDI_UNIQUE, 0,hitter,"You are splashed by acid!\n");	782	new_draw_info(NDI_UNIQUE, 0,hitter,"You are splashed by acid!\n");
783	hit_player(hitter, random_roll(0, (op->stats.dam), hitter,	783	hit_player(hitter, random_roll(0, (op->stats.dam), hitter,
784	PREFER_LOW),op, op->attacktype, 1);	784	PREFER_LOW),op, op->attacktype, 1);
785	if (was_destroyed (op, op_tag)	785	if (was_destroyed (op, op_tag)
786	|| was_destroyed (hitter, hitter_tag)	786	|| was_destroyed (hitter, hitter_tag)
787	|| abort_attack (op, hitter, simple_attack))	787	|| abort_attack (op, hitter, simple_attack))
788	goto leave;	788	goto leave;
789	}	789	}
790		790
791	/* In the new attack code, it should handle multiple attack	791	/* In the new attack code, it should handle multiple attack
792	* types in its area, so remove it from here.	792	* types in its area, so remove it from here.
793	*/	793	*/
794	dam=hit_player(op, random_roll(1, hitdam, hitter, PREFER_HIGH),	794	dam=hit_player(op, random_roll(1, hitdam, hitter, PREFER_HIGH),
795	hitter, type, 1);	795	hitter, type, 1);
796	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag)	796	if (was_destroyed (op, op_tag) || was_destroyed (hitter, hitter_tag)
797	|| abort_attack (op, hitter, simple_attack))	797	|| abort_attack (op, hitter, simple_attack))
798	goto leave;	798	goto leave;
799	} /* end of if hitter hit op */	799	} /* end of if hitter hit op */
800	/* if we missed, dam=0 */	800	/* if we missed, dam=0 */
801		801
802	/*attack_message(dam, type, op, hitter);*/	802	/*attack_message(dam, type, op, hitter);*/
803		803
…		…
832	* to the ground after a hit). What a good value for this is up to	832	* to the ground after a hit). What a good value for this is up to
833	* debate - 5000 is 5 kg, so arrows, knives, and other light weapons	833	* debate - 5000 is 5 kg, so arrows, knives, and other light weapons
834	* stick around.	834	* stick around.
835	*/	835	*/
836	if (op->weight <= 5000 && tmp->stats.hp >= 0) {	836	if (op->weight <= 5000 && tmp->stats.hp >= 0) {
837	if(tmp->head != NULL)	837	if(tmp->head != NULL)
838	tmp = tmp->head;	838	tmp = tmp->head;
839	remove_ob (op);	839	remove_ob (op);
840	op = insert_ob_in_ob(op,tmp);	840	op = insert_ob_in_ob(op,tmp);
841	if (tmp->type== PLAYER)	841	if (tmp->type== PLAYER)
842	esrv_send_item (tmp, op);	842	esrv_send_item (tmp, op);
843	return 1;	843	return 1;
844	} else	844	} else
845	return 0;	845	return 0;
846	}	846	}
847		847
848	/* hit_with_arrow() disassembles the missile, attacks the victim and	848	/* hit_with_arrow() disassembles the missile, attacks the victim and
849	* reassembles the missile.	849	* reassembles the missile.
850	*	850	*
…		…
915	if ( ! was_destroyed (victim, victim_tag)	915	if ( ! was_destroyed (victim, victim_tag)
916	&& stick_arrow (hitter, victim))	916	&& stick_arrow (hitter, victim))
917	return NULL;	917	return NULL;
918		918
919	/* Else try to put arrow on victim's map square	919	/* Else try to put arrow on victim's map square
920	* remove check for P_WALL here. If the arrow got to this	920	* remove check for P_WALL here. If the arrow got to this
921	* space, that is good enough - with the new movement code,	921	* space, that is good enough - with the new movement code,
922	* there is now the potential for lots of spaces where something	922	* there is now the potential for lots of spaces where something
923	* can fly over but not otherwise move over. What is the correct	923	* can fly over but not otherwise move over. What is the correct
924	* way to handle those otherwise?	924	* way to handle those otherwise?
925	*/	925	*/
926	if (victim_x != hitter->x || victim_y != hitter->y) {	926	if (victim_x != hitter->x || victim_y != hitter->y) {
927	remove_ob (hitter);	927	remove_ob (hitter);
928	hitter->x = victim_x;	928	hitter->x = victim_x;
929	hitter->y = victim_y;	929	hitter->y = victim_y;
930	insert_ob_in_map (hitter, victim->map, hitter,0);	930	insert_ob_in_map (hitter, victim->map, hitter,0);
…		…
934	}	934	}
935	return NULL;	935	return NULL;
936	}	936	}
937		937
938	if (hit_something && op->speed >= 10.0)	938	if (hit_something && op->speed >= 10.0)
939	op->speed -= 1.0;	939	op->speed -= 1.0;
940		940
941	/* Missile missed victim - reassemble missile */	941	/* Missile missed victim - reassemble missile */
942	if (container) {	942	if (container) {
943	remove_ob (hitter);	943	remove_ob (hitter);
944	insert_ob_in_ob (hitter, container);	944	insert_ob_in_ob (hitter, container);
…		…
950	void tear_down_wall(object *op)	950	void tear_down_wall(object *op)
951	{	951	{
952	int perc=0;	952	int perc=0;
953		953
954	if (!op->stats.maxhp) {	954	if (!op->stats.maxhp) {
955	LOG(llevError, "TEAR_DOWN wall %s had no maxhp.\n", op->name);	955	LOG(llevError, "TEAR_DOWN wall %s had no maxhp.\n", op->name);
956	perc = 1;	956	perc = 1;
957	} else if(!GET_ANIM_ID(op)) {	957	} else if(!GET_ANIM_ID(op)) {
958	/* Object has been called - no animations, so remove it */	958	/* Object has been called - no animations, so remove it */
959	if(op->stats.hp<0) {	959	if(op->stats.hp<0) {
960	remove_ob(op); /* Should update LOS */	960	remove_ob(op); /* Should update LOS */
961	free_object(op);	961	free_object(op);
962	/* Don't know why this is here - remove_ob should do it for us */	962	/* Don't know why this is here - remove_ob should do it for us */
963	/*update_position(m, x, y);*/	963	/*update_position(m, x, y);*/
964	}	964	}
965	return; /* no animations, so nothing more to do */	965	return; /* no animations, so nothing more to do */
966	}	966	}
967	perc = NUM_ANIMATIONS(op)	967	perc = NUM_ANIMATIONS(op)
968	- ((int)NUM_ANIMATIONS(op)*op->stats.hp)/op->stats.maxhp;	968	- ((int)NUM_ANIMATIONS(op)*op->stats.hp)/op->stats.maxhp;
969	if (perc >= (int) NUM_ANIMATIONS(op))	969	if (perc >= (int) NUM_ANIMATIONS(op))
970	perc = NUM_ANIMATIONS(op)-1;	970	perc = NUM_ANIMATIONS(op)-1;
971	else if (perc < 1)	971	else if (perc < 1)
972	perc = 1;	972	perc = 1;
973	SET_ANIMATION(op, perc);	973	SET_ANIMATION(op, perc);
974	update_object(op,UP_OBJ_FACE);	974	update_object(op,UP_OBJ_FACE);
975	if(perc==NUM_ANIMATIONS(op)-1) { /* Reached the last animation */	975	if(perc==NUM_ANIMATIONS(op)-1) { /* Reached the last animation */
976	if(op->face==blank_face) {	976	if(op->face==blank_face) {
977	/* If the last face is blank, remove the ob */	977	/* If the last face is blank, remove the ob */
978	remove_ob(op); /* Should update LOS */	978	remove_ob(op); /* Should update LOS */
979	free_object(op);	979	free_object(op);
980		980
981	/* remove_ob should call update_position for us */	981	/* remove_ob should call update_position for us */
982	/*update_position(m, x, y);*/	982	/*update_position(m, x, y);*/
983		983
984	} else { /* The last face was not blank, leave an image */	984	} else { /* The last face was not blank, leave an image */
985	CLEAR_FLAG(op, FLAG_BLOCKSVIEW);	985	CLEAR_FLAG(op, FLAG_BLOCKSVIEW);
986	update_all_los(op->map, op->x, op->y);	986	update_all_los(op->map, op->x, op->y);
987	op->move_block = 0;	987	op->move_block = 0;
988	CLEAR_FLAG(op, FLAG_ALIVE);	988	CLEAR_FLAG(op, FLAG_ALIVE);
989	}	989	}
990	}	990	}
991	}	991	}
992		992
993	void scare_creature(object *target, object *hitter)	993	void scare_creature(object *target, object *hitter)
994	{	994	{
…		…
1007	* take. However, it will do other effects (paralyzation, slow, etc.)	1007	* take. However, it will do other effects (paralyzation, slow, etc.)
1008	* Note - changed for PR code - we now pass the attack number and not	1008	* Note - changed for PR code - we now pass the attack number and not
1009	* the attacktype. Makes it easier for the PR code. */	1009	* the attacktype. Makes it easier for the PR code. */
1010		1010
1011	int hit_player_attacktype(object *op, object *hitter, int dam,	1011	int hit_player_attacktype(object *op, object *hitter, int dam,
1012	uint32 attacknum, int magic) {	1012	uint32 attacknum, int magic) {
1013		1013
1014	int doesnt_slay = 1;	1014	int doesnt_slay = 1;
1015		1015
1016	/* Catch anyone that may be trying to send us a bitmask instead of the number */	1016	/* Catch anyone that may be trying to send us a bitmask instead of the number */
1017	if (attacknum >= NROFATTACKS) {	1017	if (attacknum >= NROFATTACKS) {
1018	LOG(llevError, "hit_player_attacktype: Invalid attacknumber passed: %u\n", attacknum);	1018	LOG(llevError, "hit_player_attacktype: Invalid attacknumber passed: %u\n", attacknum);
1019	return 0;	1019	return 0;
1020	}	1020	}
1021		1021
1022	if (dam < 0) {	1022	if (dam < 0) {
1023	LOG(llevError,"hit_player_attacktype called with negative damage: %d\n", dam);	1023	LOG(llevError,"hit_player_attacktype called with negative damage: %d\n", dam);
1024	return 0;	1024	return 0;
1025	}	1025	}
1026		1026
1027	/* AT_INTERNAL is supposed to do exactly dam. Put a case here so	1027	/* AT_INTERNAL is supposed to do exactly dam. Put a case here so
1028	* people can't mess with that or it otherwise get confused. */	1028	* people can't mess with that or it otherwise get confused. */
1029	if (attacknum == ATNR_INTERNAL) return dam;	1029	if (attacknum == ATNR_INTERNAL) return dam;
1030		1030
1031	if (hitter->slaying) {	1031	if (hitter->slaying) {
1032	if(((op->race != NULL) && strstr(hitter->slaying, op->race)) ||	1032	if(((op->race != NULL) && strstr(hitter->slaying, op->race)) ||
1033	(op->arch && (op->arch->name != NULL) &&	1033	(op->arch && (op->arch->name != NULL) &&
1034	strstr(op->arch->name, hitter->slaying))	1034	strstr(op->arch->name, hitter->slaying))
1035	){	1035	){
1036	doesnt_slay = 0;	1036	doesnt_slay = 0;
1037	dam *= 3;	1037	dam *= 3;
1038	}	1038	}
1039	}	1039	}
1040		1040
1041	/* Adjust the damage for resistance. Note that neg. values increase damage. */	1041	/* Adjust the damage for resistance. Note that neg. values increase damage. */
1042	if (op->resist[attacknum]) {	1042	if (op->resist[attacknum]) {
1043	/* basically: dam = dam*(100-op->resist[attacknum])/100;	1043	/* basically: dam = dam*(100-op->resist[attacknum])/100;
1044	* in case 0>dam>1, we try to "simulate" a float value-effect */	1044	* in case 0>dam>1, we try to "simulate" a float value-effect */
1045	dam *= (100-op->resist[attacknum]);	1045	dam *= (100-op->resist[attacknum]);
1046	if (dam >= 100) dam /= 100;	1046	if (dam >= 100) dam /= 100;
1047	else	1047	else
1048	dam = (dam > (random_roll(0, 99, op, PREFER_LOW))) ? 1 : 0;	1048	dam = (dam > (random_roll(0, 99, op, PREFER_LOW))) ? 1 : 0;
1049	}	1049	}
1050		1050
1051	/* Special hack. By default, if immune to something, you	1051	/* Special hack. By default, if immune to something, you
1052	* shouldn't need to worry. However, acid is an exception, since	1052	* shouldn't need to worry. However, acid is an exception, since
1053	* it can still damage your items. Only include attacktypes if	1053	* it can still damage your items. Only include attacktypes if
1054	* special processing is needed */	1054	* special processing is needed */
1055		1055
1056	if ((op->resist[attacknum] >= 100) &&	1056	if ((op->resist[attacknum] >= 100) &&
1057	doesnt_slay && (attacknum != ATNR_ACID))	1057	doesnt_slay && (attacknum != ATNR_ACID))
1058	return 0;	1058	return 0;
1059		1059
1060	/* Keep this in order - makes things easier to find */	1060	/* Keep this in order - makes things easier to find */
1061		1061
1062	switch(attacknum) {	1062	switch(attacknum) {
1063	case ATNR_PHYSICAL:	1063	case ATNR_PHYSICAL:
1064	/* here also check for diseases */	1064	/* here also check for diseases */
1065	check_physically_infect(op, hitter);	1065	check_physically_infect(op, hitter);
1066	break;	1066	break;
1067		1067
1068	/* Don't need to do anything for:	1068	/* Don't need to do anything for:
1069	magic,	1069	magic,
1070	fire,	1070	fire,
1071	electricity,	1071	electricity,
1072	cold */	1072	cold */
1073		1073
1074	case ATNR_CONFUSION:	1074	case ATNR_CONFUSION:
1075	case ATNR_POISON:	1075	case ATNR_POISON:
1076	case ATNR_SLOW:	1076	case ATNR_SLOW:
1077	case ATNR_PARALYZE:	1077	case ATNR_PARALYZE:
1078	case ATNR_FEAR:	1078	case ATNR_FEAR:
1079	case ATNR_CANCELLATION:	1079	case ATNR_CANCELLATION:
1080	case ATNR_DEPLETE:	1080	case ATNR_DEPLETE:
1081	case ATNR_BLIND:	1081	case ATNR_BLIND:
1082	{	1082	{
1083	/* chance for inflicting a special attack depends on the	1083	/* chance for inflicting a special attack depends on the
1084	* difference between attacker's and defender's level	1084	* difference between attacker's and defender's level
1085	*/	1085	*/
1086	int level_diff = MIN(110, MAX(0, op->level - hitter->level));	1086	int level_diff = MIN(110, MAX(0, op->level - hitter->level));
1087		1087
1088	/* First, only creatures/players with speed can be affected.	1088	/* First, only creatures/players with speed can be affected.
1089	* Second, just getting hit doesn't mean it always affects	1089	* Second, just getting hit doesn't mean it always affects
1090	* you. Third, you still get a saving through against the	1090	* you. Third, you still get a saving through against the
1091	* effect.	1091	* effect.
1092	*/	1092	*/
1093	if (op->speed &&	1093	if (op->speed &&
1094	(QUERY_FLAG(op, FLAG_MONSTER) || op->type==PLAYER) &&	1094	(QUERY_FLAG(op, FLAG_MONSTER) || op->type==PLAYER) &&
1095	!(rndm(0, (attacknum == ATNR_SLOW?6:3)-1)) &&	1095	!(rndm(0, (attacknum == ATNR_SLOW?6:3)-1)) &&
1096	!did_make_save(op, level_diff, op->resist[attacknum]/10)) {	1096	!did_make_save(op, level_diff, op->resist[attacknum]/10)) {
1097		1097
1098	/* Player has been hit by something */	1098	/* Player has been hit by something */
1099	if (attacknum == ATNR_CONFUSION) confuse_player(op,hitter,dam);	1099	if (attacknum == ATNR_CONFUSION) confuse_player(op,hitter,dam);
1100	else if (attacknum == ATNR_POISON) poison_player(op,hitter,dam);	1100	else if (attacknum == ATNR_POISON) poison_player(op,hitter,dam);
1101	else if (attacknum == ATNR_SLOW) slow_player(op,hitter,dam);	1101	else if (attacknum == ATNR_SLOW) slow_player(op,hitter,dam);
1102	else if (attacknum == ATNR_PARALYZE) paralyze_player(op,hitter,dam);	1102	else if (attacknum == ATNR_PARALYZE) paralyze_player(op,hitter,dam);
1103	else if (attacknum == ATNR_FEAR) scare_creature(op, hitter);	1103	else if (attacknum == ATNR_FEAR) scare_creature(op, hitter);
1104	else if (attacknum == ATNR_CANCELLATION) cancellation(op);	1104	else if (attacknum == ATNR_CANCELLATION) cancellation(op);
1105	else if (attacknum == ATNR_DEPLETE) drain_stat(op);	1105	else if (attacknum == ATNR_DEPLETE) drain_stat(op);
1106	else if (attacknum == ATNR_BLIND && !QUERY_FLAG(op,FLAG_UNDEAD) &&	1106	else if (attacknum == ATNR_BLIND && !QUERY_FLAG(op,FLAG_UNDEAD) &&
1107	!QUERY_FLAG(op,FLAG_GENERATOR)) blind_player(op,hitter,dam);	1107	!QUERY_FLAG(op,FLAG_GENERATOR)) blind_player(op,hitter,dam);
1108	}	1108	}
1109	dam = 0; /* These are all effects and don't do real damage */	1109	dam = 0; /* These are all effects and don't do real damage */
1110	}	1110	}
1111	break;	1111	break;
1112	case ATNR_ACID:	1112	case ATNR_ACID:
1113	{	1113	{
1114	int flag=0;	1114	int flag=0;
1115		1115
1116	/* Items only get corroded if you're not on a battleground and	1116	/* Items only get corroded if you're not on a battleground and
1117	* if your acid resistance is below 50%. */	1117	* if your acid resistance is below 50%. */
1118	if (!op_on_battleground(op, NULL, NULL) &&	1118	if (!op_on_battleground(op, NULL, NULL) &&
1119	(op->resist[ATNR_ACID] < 50))	1119	(op->resist[ATNR_ACID] < 50))
1120	{	1120	{
1121	object *tmp;	1121	object *tmp;
1122	for(tmp=op->inv; tmp!=NULL; tmp=tmp->below) {	1122	for(tmp=op->inv; tmp!=NULL; tmp=tmp->below) {
1123	if(tmp->invisible)	1123	if(tmp->invisible)
1124	continue;	1124	continue;
1125	if(!QUERY_FLAG(tmp, FLAG_APPLIED) ||	1125	if(!QUERY_FLAG(tmp, FLAG_APPLIED) ||
1126	(tmp->resist[ATNR_ACID] >= 10))	1126	(tmp->resist[ATNR_ACID] >= 10))
1127	/* >= 10% acid res. on itmes will protect these */	1127	/* >= 10% acid res. on itmes will protect these */
1128	continue;	1128	continue;
1129	if(!(tmp->material & M_IRON))	1129	if(!(tmp->material & M_IRON))
1130	continue;	1130	continue;
1131	if(tmp->magic < -4) /* Let's stop at -5 */	1131	if(tmp->magic < -4) /* Let's stop at -5 */
1132	continue;	1132	continue;
1133	if(tmp->type==RING ||	1133	if(tmp->type==RING ||
1134	/* removed boots and gloves from exclusion list in	1134	/* removed boots and gloves from exclusion list in
1135	PR */	1135	PR */
1136	tmp->type==GIRDLE ||	1136	tmp->type==GIRDLE ||
1137	tmp->type==AMULET ||	1137	tmp->type==AMULET ||
1138	tmp->type==WAND ||	1138	tmp->type==WAND ||
1139	tmp->type==ROD ||	1139	tmp->type==ROD ||
1140	tmp->type==HORN)	1140	tmp->type==HORN)
1141	continue; /* To avoid some strange effects */	1141	continue; /* To avoid some strange effects */
1142		1142
1143	/* High damage acid has better chance of corroding	1143	/* High damage acid has better chance of corroding
1144	objects */	1144	objects */
1145	if(rndm(0, dam+4) >	1145	if(rndm(0, dam+4) >
1146	random_roll(0, 39, op, PREFER_HIGH)+2*tmp->magic) {	1146	random_roll(0, 39, op, PREFER_HIGH)+2*tmp->magic) {
1147	if(op->type == PLAYER)	1147	if(op->type == PLAYER)
1148	/* Make this more visible */	1148	/* Make this more visible */
1149	new_draw_info_format(NDI_UNIQUE|NDI_RED,0, op,	1149	new_draw_info_format(NDI_UNIQUE|NDI_RED,0, op,
1150	"The %s's acid corrodes your %s!",	1150	"The %s's acid corrodes your %s!",
1151	query_name(hitter), query_name(tmp));	1151	query_name(hitter), query_name(tmp));
1152	flag = 1;	1152	flag = 1;
1153	tmp->magic--;	1153	tmp->magic--;
1154	if(op->type == PLAYER)	1154	if(op->type == PLAYER)
1155	esrv_send_item(op, tmp);	1155	esrv_send_item(op, tmp);
1156	}	1156	}
1157	}	1157	}
1158	if(flag)	1158	if(flag)
1159	fix_player(op); /* Something was corroded */	1159	fix_player(op); /* Something was corroded */
1160	}	1160	}
1161	}	1161	}
1162	break;	1162	break;
1163	case ATNR_DRAIN:	1163	case ATNR_DRAIN:
1164	{	1164	{
1165	/* rate is the proportion of exp drained. High rate means	1165	/* rate is the proportion of exp drained. High rate means
1166	* not much is drained, low rate means a lot is drained.	1166	* not much is drained, low rate means a lot is drained.
1167	*/	1167	*/
1168	int rate;	1168	int rate;
1169		1169
1170	if(op->resist[ATNR_DRAIN] >= 0)	1170	if(op->resist[ATNR_DRAIN] >= 0)
1171	rate = 400 + op->resist[ATNR_DRAIN] * 3;	1171	rate = 400 + op->resist[ATNR_DRAIN] * 3;
1172	else	1172	else
1173	rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]);	1173	rate = 400 * 100 / (100 - op->resist[ATNR_DRAIN]);
1174		1174
1175	if(op->stats.exp <= rate) {	1175	if(op->stats.exp <= rate) {
1176	if(op->type == GOLEM)	1176	if(op->type == GOLEM)
1177	dam = 999; /* Its force is "sucked" away. 8) */	1177	dam = 999; /* Its force is "sucked" away. 8) */
1178	else	1178	else
1179	/* If we can't drain, lets try to do physical damage */	1179	/* If we can't drain, lets try to do physical damage */
1180	dam = hit_player_attacktype(op, hitter, dam, ATNR_PHYSICAL, magic);	1180	dam = hit_player_attacktype(op, hitter, dam, ATNR_PHYSICAL, magic);
1181	} else {	1181	} else {
1182	/* Randomly give the hitter some hp */	1182	/* Randomly give the hitter some hp */
1183	if(hitter->stats.hp<hitter->stats.maxhp &&	1183	if(hitter->stats.hp<hitter->stats.maxhp &&
1184	(op->level > hitter->level) &&	1184	(op->level > hitter->level) &&
1185	random_roll(0, (op->level-hitter->level+2), hitter, PREFER_HIGH)>3)	1185	random_roll(0, (op->level-hitter->level+2), hitter, PREFER_HIGH)>3)
1186	hitter->stats.hp++;	1186	hitter->stats.hp++;
1187		1187
1188	/* Can't do drains on battleground spaces.	1188	/* Can't do drains on battleground spaces.
1189	* Move the wiz check up here - before, the hitter wouldn't gain exp	1189	* Move the wiz check up here - before, the hitter wouldn't gain exp
1190	* exp, but the wiz would still lose exp! If drainee is a wiz,	1190	* exp, but the wiz would still lose exp! If drainee is a wiz,
1191	* nothing happens.	1191	* nothing happens.
1192	* Try to credit the owner. We try to display player -> player drain	1192	* Try to credit the owner. We try to display player -> player drain
1193	* attacks, hence all the != PLAYER checks.	1193	* attacks, hence all the != PLAYER checks.
1194	*/	1194	*/
1195	if (!op_on_battleground(hitter, NULL, NULL) && !QUERY_FLAG(op,FLAG_WAS_WIZ)) {	1195	if (!op_on_battleground(hitter, NULL, NULL) && !QUERY_FLAG(op,FLAG_WAS_WIZ)) {
1196	object *owner = get_owner(hitter);	1196	object *owner = get_owner(hitter);
1197		1197
1198	if (owner && owner != hitter) {	1198	if (owner && owner != hitter) {
1199	if (op->type != PLAYER || owner->type != PLAYER)	1199	if (op->type != PLAYER || owner->type != PLAYER)
1200	change_exp(owner, op->stats.exp/(rate*2),	1200	change_exp(owner, op->stats.exp/(rate*2),
1201	hitter->chosen_skill? hitter->chosen_skill->skill:NULL, SK_EXP_TOTAL);	1201	hitter->chosen_skill? hitter->chosen_skill->skill:NULL, SK_EXP_TOTAL);
1202	} else if (op->type != PLAYER || hitter->type != PLAYER) {	1202	} else if (op->type != PLAYER || hitter->type != PLAYER) {
1203	change_exp(hitter, op->stats.exp/(rate*2),	1203	change_exp(hitter, op->stats.exp/(rate*2),
1204	hitter->chosen_skill?hitter->chosen_skill->skill:NULL, 0);	1204	hitter->chosen_skill?hitter->chosen_skill->skill:NULL, 0);
1205	}	1205	}
1206	change_exp(op,-op->stats.exp/rate, NULL, 0);	1206	change_exp(op,-op->stats.exp/rate, NULL, 0);
1207	}	1207	}
1208	dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure	1208	dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure
1209	* drain attack, you won't know that you are actually sucking out EXP,	1209	* drain attack, you won't know that you are actually sucking out EXP,
1210	* as the messages will say you missed	1210	* as the messages will say you missed
1211	*/	1211	*/
1212	}	1212	}
1213	}	1213	}
1214	break;	1214	break;
1215	case ATNR_TURN_UNDEAD:	1215	case ATNR_TURN_UNDEAD:
1216	{	1216	{
1217	if (QUERY_FLAG(op,FLAG_UNDEAD)) {	1217	if (QUERY_FLAG(op,FLAG_UNDEAD)) {
1218	object *owner = get_owner(hitter) == NULL ? hitter : get_owner(hitter);	1218	object *owner = get_owner(hitter) == NULL ? hitter : get_owner(hitter);
1219	object *god = find_god (determine_god (owner));	1219	object *god = find_god (determine_god (owner));
1220	int div = 1;	1220	int div = 1;
1221		1221
1222	/* if undead are not an enemy of your god, you turn them	1222	/* if undead are not an enemy of your god, you turn them
1223	* at half strength */	1223	* at half strength */
1224	if (! god || ! god->slaying ||	1224	if (! god || ! god->slaying ||
1225	strstr (god->slaying, undead_name) == NULL)	1225	strstr (god->slaying, undead_name) == NULL)
1226	div = 2;	1226	div = 2;
1227	/* Give a bonus if you resist turn undead */	1227	/* Give a bonus if you resist turn undead */
1228	if (op->level * div <	1228	if (op->level * div <
1229	(turn_bonus[owner->stats.Wis]+owner->level +	1229	(turn_bonus[owner->stats.Wis]+owner->level +
1230	(op->resist[ATNR_TURN_UNDEAD]/100)))	1230	(op->resist[ATNR_TURN_UNDEAD]/100)))
1231	scare_creature(op, owner);	1231	scare_creature(op, owner);
1232	}	1232	}
1233	else	1233	else
1234	dam = 0; /* don't damage non undead - should we damage	1234	dam = 0; /* don't damage non undead - should we damage
1235	undead? */	1235	undead? */
1236	} break;	1236	} break;
1237	case ATNR_DEATH:	1237	case ATNR_DEATH:
1238	deathstrike_player(op, hitter, &dam);	1238	deathstrike_player(op, hitter, &dam);
1239	break;	1239	break;
1240	case ATNR_CHAOS:	1240	case ATNR_CHAOS:
1241	LOG(llevError,	1241	LOG(llevError,
1242	"%s was hit by %s with non-specific chaos.\n",	1242	"%s was hit by %s with non-specific chaos.\n",
1243	query_name(op),	1243	query_name(op),
1244	query_name(hitter));	1244	query_name(hitter));
1245	dam = 0;	1245	dam = 0;
1246	break;	1246	break;
1247	case ATNR_COUNTERSPELL:	1247	case ATNR_COUNTERSPELL:
1248	LOG(llevError,	1248	LOG(llevError,
1249	"%s was hit by %s with counterspell attack.\n",	1249	"%s was hit by %s with counterspell attack.\n",
1250	query_name(op),	1250	query_name(op),
1251	query_name(hitter));	1251	query_name(hitter));
1252	dam = 0;	1252	dam = 0;
1253	/* This should never happen. Counterspell is handled	1253	/* This should never happen. Counterspell is handled
1254	* seperately and filtered out. If this does happen,	1254	* seperately and filtered out. If this does happen,
1255	* Counterspell has no effect on anything but spells, so it	1255	* Counterspell has no effect on anything but spells, so it
1256	* does no damage. */	1256	* does no damage. */
1257	break;	1257	break;
1258	case ATNR_HOLYWORD:	1258	case ATNR_HOLYWORD:
1259	{	1259	{
1260	/* This has already been handled by hit_player,	1260	/* This has already been handled by hit_player,
1261	* no need to check twice -- DAMN */	1261	* no need to check twice -- DAMN */
1262		1262
1263	object *owner = get_owner(hitter)==NULL?hitter:get_owner(hitter);	1263	object *owner = get_owner(hitter)==NULL?hitter:get_owner(hitter);
1264		1264
1265	/* As with turn undead above, give a bonus on the saving throw */	1265	/* As with turn undead above, give a bonus on the saving throw */
1266	if((op->level+(op->resist[ATNR_HOLYWORD]/100)) <	1266	if((op->level+(op->resist[ATNR_HOLYWORD]/100)) <
1267	owner->level+turn_bonus[owner->stats.Wis])	1267	owner->level+turn_bonus[owner->stats.Wis])
1268	scare_creature(op, owner);	1268	scare_creature(op, owner);
1269	} break;	1269	} break;
1270	case ATNR_LIFE_STEALING:	1270	case ATNR_LIFE_STEALING:
1271	{	1271	{
1272	int new_hp;	1272	int new_hp;
1273	/* this is replacement to drain for players, instead of taking	1273	/* this is replacement to drain for players, instead of taking
1274	* exp it takes hp. It is geared for players, probably not	1274	* exp it takes hp. It is geared for players, probably not
1275	* much use giving it to monsters	1275	* much use giving it to monsters
1276	*	1276	*
1277	* life stealing doesn't do a lot of damage, but it gives the	1277	* life stealing doesn't do a lot of damage, but it gives the
1278	* damage it does do to the player. Given that,	1278	* damage it does do to the player. Given that,
1279	* it only does 1/10'th normal damage (hence the divide by	1279	* it only does 1/10'th normal damage (hence the divide by
1280	* 1000).	1280	* 1000).
1281	*/	1281	*/
1282	/* You can't steal life from something undead */	1282	/* You can't steal life from something undead */
1283	if ((op->type == GOLEM) || (QUERY_FLAG(op, FLAG_UNDEAD))) return 0;	1283	if ((op->type == GOLEM) || (QUERY_FLAG(op, FLAG_UNDEAD))) return 0;
1284	/* If drain protection is higher than life stealing, use that */	1284	/* If drain protection is higher than life stealing, use that */
1285	if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])	1285	if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])
1286	dam = (dam*(100 - op->resist[ATNR_DRAIN])) / 3000;	1286	dam = (dam*(100 - op->resist[ATNR_DRAIN])) / 3000;
1287	else dam = (dam*(100 - op->resist[ATNR_LIFE_STEALING])) / 3000;	1287	else dam = (dam*(100 - op->resist[ATNR_LIFE_STEALING])) / 3000;
1288	/* You die at -1 hp, not zero. */	1288	/* You die at -1 hp, not zero. */
1289	if (dam > (op->stats.hp+1)) dam = op->stats.hp+1;	1289	if (dam > (op->stats.hp+1)) dam = op->stats.hp+1;
1290	new_hp = hitter->stats.hp + dam;	1290	new_hp = hitter->stats.hp + dam;
1291	if (new_hp > hitter->stats.maxhp) new_hp = hitter->stats.maxhp;	1291	if (new_hp > hitter->stats.maxhp) new_hp = hitter->stats.maxhp;
1292	if (new_hp > hitter->stats.hp) hitter->stats.hp = new_hp;	1292	if (new_hp > hitter->stats.hp) hitter->stats.hp = new_hp;
1293	}	1293	}
1294	}	1294	}
1295	return dam;	1295	return dam;
1296	}	1296	}
1297		1297
…		…
1320	int pk=0; /* true if op and what controls hitter are both players*/	1320	int pk=0; /* true if op and what controls hitter are both players*/
1321	object *owner=NULL;	1321	object *owner=NULL;
1322	object *skop=NULL;	1322	object *skop=NULL;
1323		1323
1324	if (op->stats.hp>=0)	1324	if (op->stats.hp>=0)
1325	return -1;	1325	return -1;
1326		1326
1327	if (INVOKE_OBJECT (KILL, op, ARG_OBJECT (hitter)))	1327	if (INVOKE_OBJECT (KILL, op, ARG_OBJECT (hitter)))
1328	return 0;	1328	return 0;
1329		1329
1330	/* maxdam needs to be the amount of damage it took to kill	1330	/* maxdam needs to be the amount of damage it took to kill
…		…
1332	* adjusted the creatures HP total, so that is negative.	1332	* adjusted the creatures HP total, so that is negative.
1333	*/	1333	*/
1334	maxdam = dam + op->stats.hp + 1;	1334	maxdam = dam + op->stats.hp + 1;
1335		1335
1336	if(QUERY_FLAG(op,FLAG_BLOCKSVIEW))	1336	if(QUERY_FLAG(op,FLAG_BLOCKSVIEW))
1337	update_all_los(op->map,op->x, op->y); /* makes sure los will be recalculated */	1337	update_all_los(op->map,op->x, op->y); /* makes sure los will be recalculated */
1338		1338
1339	if(op->type==DOOR) {	1339	if(op->type==DOOR) {
1340	op->speed = 0.1;	1340	op->speed = 0.1;
1341	update_ob_speed(op);	1341	update_ob_speed(op);
1342	op->speed_left= -0.05;	1342	op->speed_left= -0.05;
1343	return maxdam;	1343	return maxdam;
1344	}	1344	}
1345	if(QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER) {	1345	if(QUERY_FLAG (op, FLAG_FRIENDLY) && op->type != PLAYER) {
1346	remove_friendly_object(op);	1346	remove_friendly_object(op);
1347	if (get_owner (op) != NULL && op->owner->type == PLAYER &&	1347	if (get_owner (op) != NULL && op->owner->type == PLAYER &&
1348	op->owner->contr->ranges[range_golem] == op) {	1348	op->owner->contr->ranges[range_golem] == op) {
1349	op->owner->contr->ranges[range_golem]=NULL;	1349	op->owner->contr->ranges[range_golem]=NULL;
1350	op->owner->contr->golem_count=0;	1350	op->owner->contr->golem_count=0;
1351	}	1351	}
1352		1352
1353	remove_ob(op);	1353	remove_ob(op);
1354	free_object(op);	1354	free_object(op);
1355	return maxdam;	1355	return maxdam;
1356	}	1356	}
1357		1357
1358	/* Now lets start dealing with experience we get for killing something */	1358	/* Now lets start dealing with experience we get for killing something */
1359		1359
1360	owner=get_owner(hitter);	1360	owner=get_owner(hitter);
1361	if(owner==NULL)	1361	if(owner==NULL)
1362	owner=hitter;	1362	owner=hitter;
1363		1363
1364	/* is the victim (op) standing on battleground? */	1364	/* is the victim (op) standing on battleground? */
1365	if (op_on_battleground(op, NULL, NULL)) battleg=1;	1365	if (op_on_battleground(op, NULL, NULL)) battleg=1;
1366		1366
1367	/* is this player killing?*/	1367	/* is this player killing?*/
1368	if (op->type == PLAYER && owner->type == PLAYER) pk=1;	1368	if (op->type == PLAYER && owner->type == PLAYER) pk=1;
1369		1369
1370	/* Player killed something */	1370	/* Player killed something */
1371	if(owner->type==PLAYER) {	1371	if(owner->type==PLAYER) {
1372	Log_Kill(owner->name,	1372	Log_Kill(owner->name,
1373	query_name(op),op->type,	1373	query_name(op),op->type,
1374	(owner!=hitter) ? query_name(hitter) : NULL,	1374	(owner!=hitter) ? query_name(hitter) : NULL,
1375	(owner!=hitter) ? hitter->type : 0);	1375	(owner!=hitter) ? hitter->type : 0);
1376		1376
1377	/* Log players killing other players - makes it easier to detect	1377	/* Log players killing other players - makes it easier to detect
1378	* and filter out malicious player killers - that is why the	1378	* and filter out malicious player killers - that is why the
1379	* ip address is included.	1379	* ip address is included.
1380	*/	1380	*/
1381	if (op->type == PLAYER && !battleg) {	1381	if (op->type == PLAYER && !battleg) {
1382	time_t t=time(NULL);	1382	time_t t=time(NULL);
1383	struct tm *tmv;	1383	struct tm *tmv;
1384	char buf[256];	1384	char buf[256];
1385		1385
1386	tmv = localtime(&t);	1386	tmv = localtime(&t);
1387	strftime(buf, 256,"%a %b %d %H:%M:%S %Y", tmv);	1387	strftime(buf, 256,"%a %b %d %H:%M:%S %Y", tmv);
1388		1388
1389	LOG(llevInfo,"%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n",	1389	LOG(llevInfo,"%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n",
1390	buf, owner->name, owner->contr->socket.host, query_name(op));	1390	buf, owner->name, owner->contr->socket.host, query_name(op));
1391	}	1391	}
1392		1392
1393	/* try to filter some things out - basically, if you are	1393	/* try to filter some things out - basically, if you are
1394	* killing a level 1 creature and your level 20, you	1394	* killing a level 1 creature and your level 20, you
1395	* probably don't want to see that.	1395	* probably don't want to see that.
1396	*/	1396	*/
1397	if ( owner->level < op->level * 2|| op->stats.exp>1000) {	1397	if ( owner->level < op->level * 2|| op->stats.exp>1000) {
1398	if(owner!=hitter) {	1398	if(owner!=hitter) {
1399	new_draw_info_format(NDI_BLACK, 0, owner,	1399	new_draw_info_format(NDI_BLACK, 0, owner,
1400	"You killed %s with %s.",query_name(op),	1400	"You killed %s with %s.",query_name(op),
1401	query_name(hitter));	1401	query_name(hitter));
1402	}	1402	}
1403	else {	1403	else {
1404	new_draw_info_format(NDI_BLACK, 0, owner,	1404	new_draw_info_format(NDI_BLACK, 0, owner,
1405	"You killed %s.",query_name(op));	1405	"You killed %s.",query_name(op));
1406	}	1406	}
1407	/* Only play sounds for melee kills */	1407	/* Only play sounds for melee kills */
1408	if (hitter->type == PLAYER)	1408	if (hitter->type == PLAYER)
1409	play_sound_map(owner->map, owner->x, owner->y, SOUND_PLAYER_KILLS);	1409	play_sound_map(owner->map, owner->x, owner->y, SOUND_PLAYER_KILLS);
1410	}	1410	}
1411		1411
1412	/* If a player kills another player, not on	1412	/* If a player kills another player, not on
1413	* battleground, the "killer" looses 1 luck. Since this is	1413	* battleground, the "killer" looses 1 luck. Since this is
1414	* not reversible, it's actually quite a pain IMHO. -AV	1414	* not reversible, it's actually quite a pain IMHO. -AV
1415	* Fix bug in that we were changing the luck of the hitter, not	1415	* Fix bug in that we were changing the luck of the hitter, not
1416	* player that the object belonged to - so if you killed another player	1416	* player that the object belonged to - so if you killed another player
1417	* with spells, pets, whatever, there was no penalty.	1417	* with spells, pets, whatever, there was no penalty.
1418	* Changed to make luck penalty configurable in settings.	1418	* Changed to make luck penalty configurable in settings.
1419	*/	1419	*/
1420	if(op->type == PLAYER && owner != op && !battleg)	1420	if(op->type == PLAYER && owner != op && !battleg)
1421	change_luck(owner, -settings.pk_luck_penalty);	1421	change_luck(owner, -settings.pk_luck_penalty);
1422		1422
1423	/* This code below deals with finding the appropriate skill	1423	/* This code below deals with finding the appropriate skill
1424	* to credit exp to. This is a bit problematic - we should	1424	* to credit exp to. This is a bit problematic - we should
1425	* probably never really have to look at current_weapon->skill	1425	* probably never really have to look at current_weapon->skill
1426	*/	1426	*/
1427	skill = NULL;	1427	skill = NULL;
1428	if (hitter->skill && hitter->type!=PLAYER) skill = hitter->skill;	1428	if (hitter->skill && hitter->type!=PLAYER) skill = hitter->skill;
1429	else if (owner->chosen_skill) {	1429	else if (owner->chosen_skill) {
1430	skill = owner->chosen_skill->skill;	1430	skill = owner->chosen_skill->skill;
1431	skop = owner->chosen_skill;	1431	skop = owner->chosen_skill;
1432	}	1432	}
1433	else if (QUERY_FLAG(owner, FLAG_READY_WEAPON)) skill=owner->current_weapon->skill;	1433	else if (QUERY_FLAG(owner, FLAG_READY_WEAPON)) skill=owner->current_weapon->skill;
1434	else	1434	else
1435	LOG(llevError,"kill_object - unable to find skill that killed monster\n");	1435	LOG(llevError,"kill_object - unable to find skill that killed monster\n");
1436		1436
1437	/* We have the skill we want to credit to - now find the object this goes	1437	/* We have the skill we want to credit to - now find the object this goes
1438	* to. Make sure skop is an actual skill, and not a skill tool!	1438	* to. Make sure skop is an actual skill, and not a skill tool!
1439	*/	1439	*/
1440	if ((!skop || skop->type != SKILL) && skill) {	1440	if ((!skop || skop->type != SKILL) && skill) {
1441	int i;	1441	int i;
1442		1442
1443	for (i=0; i<NUM_SKILLS; i++)	1443	for (i=0; i<NUM_SKILLS; i++)
1444	if (owner->contr->last_skill_ob[i] &&	1444	if (owner->contr->last_skill_ob[i] &&
1445	!strcmp(owner->contr->last_skill_ob[i]->skill, skill)) {	1445	!strcmp(owner->contr->last_skill_ob[i]->skill, skill)) {
1446	skop = owner->contr->last_skill_ob[i];	1446	skop = owner->contr->last_skill_ob[i];
1447	break;	1447	break;
1448	}	1448	}
1449	}	1449	}
1450	} /* Was it a player that hit somethign */	1450	} /* Was it a player that hit somethign */
1451	else {	1451	else {
1452	skill = NULL;	1452	skill = NULL;
1453	}	1453	}
1454		1454
1455	/* Pet (or spell) killed something. */	1455	/* Pet (or spell) killed something. */
1456	if(owner != hitter ) {	1456	if(owner != hitter ) {
1457	(void) sprintf(buf,"%s killed %s with %s%s%s.",owner->name,	1457	(void) sprintf(buf,"%s killed %s with %s%s%s.",owner->name,
1458	query_name(op),query_name(hitter), battleg? " (duel)":"", pk? " (pk)":"");	1458	query_name(op),query_name(hitter), battleg? " (duel)":"", pk? " (pk)":"");
1459	}	1459	}
1460	else {	1460	else {
1461	(void) sprintf(buf,"%s killed %s%s%s%s.",hitter->name,op->name,	1461	(void) sprintf(buf,"%s killed %s%s%s%s.",hitter->name,op->name,
1462	(QUERY_FLAG(hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?	1462	(QUERY_FLAG(hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?
1463	" in hand to hand combat":"", battleg? " (duel)":"", pk? " (pk)":"");	1463	" in hand to hand combat":"", battleg? " (duel)":"", pk? " (pk)":"");
1464	}	1464	}
1465	/* These may have been set in the player code section above */	1465	/* These may have been set in the player code section above */
1466	if (!skop) skop = hitter->chosen_skill;	1466	if (!skop) skop = hitter->chosen_skill;
1467	if (!skill && skop) skill=skop->skill;	1467	if (!skill && skop) skill=skop->skill;
1468		1468
1469	new_draw_info(NDI_ALL, op->type==PLAYER?1:10, NULL, buf);	1469	new_draw_info(NDI_ALL, op->type==PLAYER?1:10, NULL, buf);
1470		1470
1471		1471
1472	/* If you didn't kill yourself, and your not the wizard */	1472	/* If you didn't kill yourself, and your not the wizard */
1473	if(owner!=op && !QUERY_FLAG(op, FLAG_WAS_WIZ)) {	1473	if(owner!=op && !QUERY_FLAG(op, FLAG_WAS_WIZ)) {
1474	int exp;	1474	int exp;
1475		1475
1476	/* Really don't give much experience for killing other players */	1476	/* Really don't give much experience for killing other players */
1477	// schmorp: temporary? reduce the amount of exp gained for pking enourmously	1477	// schmorp: temporary? reduce the amount of exp gained for pking enourmously
1478	if (op->type==PLAYER) {	1478	if (op->type==PLAYER) {
1479	if (battleg) {	1479	if (battleg) {
1480	new_draw_info(NDI_UNIQUE, 0,owner, "Your foe has fallen!");	1480	new_draw_info(NDI_UNIQUE, 0,owner, "Your foe has fallen!");
1481	new_draw_info(NDI_UNIQUE, 0,owner, "VICTORY!!!");	1481	new_draw_info(NDI_UNIQUE, 0,owner, "VICTORY!!!");
1482	}	1482	}
1483	else	1483	else
1484	exp = op->stats.exp / 1000;	1484	exp = op->stats.exp / 1000;
1485	}	1485	}
1486	else	1486	else
1487	exp = calc_skill_exp(owner, op, skop);	1487	exp = calc_skill_exp(owner, op, skop);
1488		1488
1489	/* if op is standing on "battleground" (arena), no way to gain	1489	/* if op is standing on "battleground" (arena), no way to gain
1490	* exp by killing him	1490	* exp by killing him
1491	*/	1491	*/
1492	if (battleg) exp = 0;	1492	if (battleg) exp = 0;
1493		1493
1494	/* Don't know why this is set this way - doesn't make	1494	/* Don't know why this is set this way - doesn't make
1495	* sense to just divide everything by two for no reason.	1495	* sense to just divide everything by two for no reason.
1496	*/	1496	*/
1497		1497
1498	if (!settings.simple_exp)	1498	if (!settings.simple_exp)
1499	exp=exp/2;	1499	exp=exp/2;
1500		1500
1501	if(owner->type!=PLAYER || owner->contr->party==NULL) {	1501	if(owner->type!=PLAYER || owner->contr->party==NULL) {
1502	change_exp(owner,exp, skill, 0);	1502	change_exp(owner,exp, skill, 0);
1503	}	1503	}
1504	else {	1504	else {
1505	int shares=0,count=0;	1505	int shares=0,count=0;
1506		1506
1507	player *pl;	1507	player *pl;
1508		1508
1509	partylist *party=owner->contr->party;	1509	partylist *party=owner->contr->party;
1510	#ifdef PARTY_KILL_LOG	1510	#ifdef PARTY_KILL_LOG
1511	add_kill_to_party(party, query_name(owner), query_name(op), exp);	1511	add_kill_to_party(party, query_name(owner), query_name(op), exp);
1512	#endif	1512	#endif
1513	for(pl=first_player;pl!=NULL;pl=pl->next) {	1513	for(pl=first_player;pl!=NULL;pl=pl->next) {
1514	if(party && pl->ob->contr->party==party && on_same_map(pl->ob, owner)) {
1515	count++;
1516	shares+=(pl->ob->level+4);
1517	}
1518	}
1519	if(count==1 || shares>exp)
1520	change_exp(owner,exp, skill, SK_EXP_TOTAL);
1521	else {
1522	int share=exp/shares,given=0,nexp;
1523	for(pl=first_player;pl!=NULL;pl=pl->next) {
1524	if(party && pl->ob->contr->party==party && on_same_map(pl->ob, owner)) {	1514	if(party && pl->ob->contr->party==party && on_same_map(pl->ob, owner)) {
1525	nexp=(pl->ob->level+4)*share;	1515	count++;
		1516	shares+=(pl->ob->level+4);
		1517	}
		1518	}
		1519	if(count==1 || shares>exp)
		1520	change_exp(owner,exp, skill, SK_EXP_TOTAL);
		1521	else {
		1522	int share=exp/shares,given=0,nexp;
		1523	for(pl=first_player;pl!=NULL;pl=pl->next) {
		1524	if(party && pl->ob->contr->party==party && on_same_map(pl->ob, owner)) {
		1525	nexp=(pl->ob->level+4)*share;
1526	change_exp(pl->ob,nexp, skill, SK_EXP_TOTAL);	1526	change_exp(pl->ob,nexp, skill, SK_EXP_TOTAL);
1527	given+=nexp;	1527	given+=nexp;
1528	}	1528	}
1529	}	1529	}
1530	exp-=given;	1530	exp-=given;
1531	/* give any remainder to the player */	1531	/* give any remainder to the player */
1532	change_exp(owner,exp, skill, SK_EXP_ADD_SKILL);	1532	change_exp(owner,exp, skill, SK_EXP_ADD_SKILL);
1533	}	1533	}
1534	} /* else part of a party */	1534	} /* else part of a party */
1535		1535
1536	} /* end if person didn't kill himself */	1536	} /* end if person didn't kill himself */
1537		1537
1538	if(op->type!=PLAYER) {	1538	if(op->type!=PLAYER) {
1539	if(QUERY_FLAG(op,FLAG_FRIENDLY)) {	1539	if(QUERY_FLAG(op,FLAG_FRIENDLY)) {
1540	object *owner1 = get_owner(op);	1540	object *owner1 = get_owner(op);
1541		1541
1542	if(owner1!= NULL && owner1->type == PLAYER) {	1542	if(owner1!= NULL && owner1->type == PLAYER) {
1543	play_sound_player_only(owner1->contr, SOUND_PET_IS_KILLED,0,0);	1543	play_sound_player_only(owner1->contr, SOUND_PET_IS_KILLED,0,0);
1544	/* Maybe we should include the owner that killed this, maybe not */	1544	/* Maybe we should include the owner that killed this, maybe not */
1545	new_draw_info_format(NDI_UNIQUE, 0,owner1,"Your pet, the %s, is killed by %s.",	1545	new_draw_info_format(NDI_UNIQUE, 0,owner1,"Your pet, the %s, is killed by %s.",
1546	op->name,hitter->name);	1546	op->name,hitter->name);
1547	}	1547	}
1548	remove_friendly_object(op);	1548	remove_friendly_object(op);
1549	}	1549	}
1550	remove_ob(op);	1550	remove_ob(op);
1551	free_object(op);	1551	free_object(op);
1552	}	1552	}
1553	/* Player has been killed! */	1553	/* Player has been killed! */
1554	else {	1554	else {
1555	if(owner->type==PLAYER) {	1555	if(owner->type==PLAYER) {
1556	snprintf(op->contr->killer, BIG_NAME, "%s the %s",owner->name,owner->contr->title);	1556	snprintf(op->contr->killer, BIG_NAME, "%s the %s",owner->name,owner->contr->title);
1557	}	1557	}
1558	else {	1558	else {
1559	strncpy(op->contr->killer,hitter->name,BIG_NAME);	1559	strncpy(op->contr->killer,hitter->name,BIG_NAME);
1560	op->contr->killer[BIG_NAME-1]='\0';	1560	op->contr->killer[BIG_NAME-1]='\0';
1561	}	1561	}
1562	}	1562	}
1563	/* This was return -1 - that doesn't seem correct - if we return -1, process	1563	/* This was return -1 - that doesn't seem correct - if we return -1, process
1564	* continues in the calling function.	1564	* continues in the calling function.
1565	*/	1565	*/
1566	return maxdam;	1566	return maxdam;
…		…
1571	*/	1571	*/
1572		1572
1573	int friendly_fire(object *op, object *hitter){	1573	int friendly_fire(object *op, object *hitter){
1574	object *owner;	1574	object *owner;
1575	int friendlyfire;	1575	int friendlyfire;
1576		1576
1577	if (hitter->head) hitter=hitter->head;	1577	if (hitter->head) hitter=hitter->head;
1578		1578
1579	friendlyfire = 0;	1579	friendlyfire = 0;
1580		1580
1581	if(op->type == PLAYER) {	1581	if(op->type == PLAYER) {
1582	if (op_on_battleground (hitter, 0, 0))	1582	if (op_on_battleground (hitter, 0, 0))
1583	return 0;	1583	return 0;
1584		1584
1585	if(hitter->type == PLAYER && hitter->contr->peaceful == 1)	1585	if(hitter->type == PLAYER && hitter->contr->peaceful == 1)
1586	return 1;	1586	return 1;
1587		1587
1588	if((owner = get_owner(hitter))!=NULL) {	1588	if((owner = get_owner(hitter))!=NULL) {
1589	if(owner->type == PLAYER && owner->contr->peaceful == 1)	1589	if(owner->type == PLAYER && owner->contr->peaceful == 1)
1590	friendlyfire = 2;	1590	friendlyfire = 2;
1591	}	1591	}
1592		1592
1593	if (hitter->type == SPELL || hitter->type == POISONING ||	1593	if (hitter->type == SPELL || hitter->type == POISONING ||
1594	hitter->type == DISEASE || hitter->type == RUNE)	1594	hitter->type == DISEASE || hitter->type == RUNE)
1595	friendlyfire = 0;	1595	friendlyfire = 0;
1596	}	1596	}
1597	return friendlyfire;	1597	return friendlyfire;
1598	}	1598	}
1599		1599
1600		1600
…		…
1639		1639
1640	op_tag = op->count;	1640	op_tag = op->count;
1641	hitter_tag = hitter->count;	1641	hitter_tag = hitter->count;
1642		1642
1643	if (body_attack) {	1643	if (body_attack) {
1644	/* slow and paralyze must hit the head. But we don't want to just	1644	/* slow and paralyze must hit the head. But we don't want to just
1645	* return - we still need to process other attacks the spell still	1645	* return - we still need to process other attacks the spell still
1646	* might have. So just remove the paralyze and slow attacktypes,	1646	* might have. So just remove the paralyze and slow attacktypes,
1647	* and keep on processing if we have other attacktypes.	1647	* and keep on processing if we have other attacktypes.
1648	* return if only magic or nothing is left - under normal code	1648	* return if only magic or nothing is left - under normal code
1649	* we don't attack with pure magic if there is another attacktype.	1649	* we don't attack with pure magic if there is another attacktype.
1650	* Only do processing if the initial attacktype includes one of those	1650	* Only do processing if the initial attacktype includes one of those
1651	* attack so we don't cancel out things like magic bullet.	1651	* attack so we don't cancel out things like magic bullet.
1652	*/	1652	*/
1653	if (type & (AT_PARALYZE | AT_SLOW)) {	1653	if (type & (AT_PARALYZE | AT_SLOW)) {
1654	type &= ~(AT_PARALYZE | AT_SLOW);	1654	type &= ~(AT_PARALYZE | AT_SLOW);
1655	if (!type || type==AT_MAGIC) return 0;	1655	if (!type || type==AT_MAGIC) return 0;
1656	}	1656	}
1657	}	1657	}
1658		1658
1659	if ( ! simple_attack && op->type == DOOR) {	1659	if ( ! simple_attack && op->type == DOOR) {
1660	object *tmp;	1660	object *tmp;
1661	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	1661	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
…		…
1673	/* FIXME: If a player is killed by a rune in a door, the	1673	/* FIXME: If a player is killed by a rune in a door, the
1674	* was_destroyed() check above doesn't return, and might get here.	1674	* was_destroyed() check above doesn't return, and might get here.
1675	*/	1675	*/
1676	LOG (llevDebug, "victim (arch %s, name %s) already dead in "	1676	LOG (llevDebug, "victim (arch %s, name %s) already dead in "
1677	"hit_player()\n", op->arch->name, op->name);	1677	"hit_player()\n", op->arch->name, op->name);
1678	return 0;	1678	return 0;
1679	}	1679	}
1680		1680
1681	#ifdef ATTACK_DEBUG	1681	#ifdef ATTACK_DEBUG
1682	LOG(llevDebug,"hit player: attacktype %d, dam %d\n", type, dam);	1682	LOG(llevDebug,"hit player: attacktype %d, dam %d\n", type, dam);
1683	#endif	1683	#endif
…		…
1685	if (magic) {	1685	if (magic) {
1686	/* basically: dam = dam*(100-op->resist[attacknum])/100;	1686	/* basically: dam = dam*(100-op->resist[attacknum])/100;
1687	* in case 0>dam>1, we try to "simulate" a float value-effect */	1687	* in case 0>dam>1, we try to "simulate" a float value-effect */
1688	dam = dam*(100-op->resist[ATNR_MAGIC]);	1688	dam = dam*(100-op->resist[ATNR_MAGIC]);
1689	if (dam >= 100)	1689	if (dam >= 100)
1690	dam /= 100;	1690	dam /= 100;
1691	else	1691	else
1692	dam = (dam > (rndm(0, 99))) ? 1 : 0;	1692	dam = (dam > (rndm(0, 99))) ? 1 : 0;
1693	}	1693	}
1694		1694
1695	/* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map	1695	/* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map
1696	* If the attacktype still has chaos, shuffle it, then clear the Chaos bit	1696	* If the attacktype still has chaos, shuffle it, then clear the Chaos bit
1697	*/	1697	*/
…		…
1705	* holyword is part of an attacktype, then make sure the creature is	1705	* holyword is part of an attacktype, then make sure the creature is
1706	* a proper match, otherwise no damage.	1706	* a proper match, otherwise no damage.
1707	*/	1707	*/
1708	if (type & AT_HOLYWORD) {	1708	if (type & AT_HOLYWORD) {
1709	object *god;	1709	object *god;
1710	if ((!hitter->slaying ||	1710	if ((!hitter->slaying ||
1711	(!(op->race && strstr(hitter->slaying,op->race)) &&	1711	(!(op->race && strstr(hitter->slaying,op->race)) &&
1712	!(op->name && strstr(hitter->slaying,op->name)))) &&	1712	!(op->name && strstr(hitter->slaying,op->name)))) &&
1713	(!QUERY_FLAG(op,FLAG_UNDEAD) ||	1713	(!QUERY_FLAG(op,FLAG_UNDEAD) ||
1714	(hitter->title != NULL	1714	(hitter->title != NULL
1715	&& (god = find_god(determine_god(hitter))) != NULL	1715	&& (god = find_god(determine_god(hitter))) != NULL
1716	&& god->race != NULL	1716	&& god->race != NULL
1717	&& strstr(god->race,undead_name) != NULL)))	1717	&& strstr(god->race,undead_name) != NULL)))
1718	return 0;	1718	return 0;
1719	}	1719	}
1720		1720
1721	maxattacktype = type; /* initialize this to something */	1721	maxattacktype = type; /* initialize this to something */
1722	for (attacknum=0; attacknum<NROFATTACKS; attacknum++, attacktype=1<<attacknum) {	1722	for (attacknum=0; attacknum<NROFATTACKS; attacknum++, attacktype=1<<attacknum) {
1723	/* Magic isn't really a true attack type - it gets combined with other	1723	/* Magic isn't really a true attack type - it gets combined with other
1724	* attack types. As such, skip it over. However, if magic is	1724	* attack types. As such, skip it over. However, if magic is
1725	* the only attacktype in the group, then still attack with it	1725	* the only attacktype in the group, then still attack with it
1726	*/
1727	if ((attacktype==AT_MAGIC) && (type & ~AT_MAGIC)) continue;
1728
1729	/* Go through and hit the player with each attacktype, one by one.
1730	* hit_player_attacktype only figures out the damage, doesn't inflict
1731	* it. It will do the appropriate action for attacktypes with
1732	* effects (slow, paralization, etc.
1733	*/	1726	*/
		1727	if ((attacktype==AT_MAGIC) && (type & ~AT_MAGIC)) continue;
		1728
		1729	/* Go through and hit the player with each attacktype, one by one.
		1730	* hit_player_attacktype only figures out the damage, doesn't inflict
		1731	* it. It will do the appropriate action for attacktypes with
		1732	* effects (slow, paralization, etc.
		1733	*/
1734	if (type & attacktype) {	1734	if (type & attacktype) {
1735	ndam=hit_player_attacktype(op,hitter,dam,attacknum,magic);	1735	ndam=hit_player_attacktype(op,hitter,dam,attacknum,magic);
1736	/* the >= causes us to prefer messages from special attacks, if	1736	/* the >= causes us to prefer messages from special attacks, if
1737	* the damage is equal.	1737	* the damage is equal.
1738	*/	1738	*/
1739	if (ndam >= maxdam) {	1739	if (ndam >= maxdam) {
1740	maxdam = ndam;	1740	maxdam = ndam;
1741	maxattacktype = 1<<attacknum;	1741	maxattacktype = 1<<attacknum;
		1742	}
		1743	}
1742	}	1744	}
1743	}	1745
1744	}
1745
1746	/* if this is friendly fire then do a set % of damage only	1746	/* if this is friendly fire then do a set % of damage only
1747	* Note - put a check in to make sure this attack is actually	1747	* Note - put a check in to make sure this attack is actually
1748	* doing damage - otherwise, the +1 in the code below will make	1748	* doing damage - otherwise, the +1 in the code below will make
1749	* an attack do damage before when it otherwise didn't	1749	* an attack do damage before when it otherwise didn't
1750	*/	1750	*/
1751	friendlyfire = friendly_fire(op, hitter);	1751	friendlyfire = friendly_fire(op, hitter);
1752	if (friendlyfire && maxdam){	1752	if (friendlyfire && maxdam){
1753	maxdam = ((dam * settings.set_friendly_fire) / 100);	1753	maxdam = ((dam * settings.set_friendly_fire) / 100);
1754	#ifndef COZY_SERVER	1754	#ifndef COZY_SERVER
1755	maxdam++;	1755	maxdam++;
1756	#endif	1756	#endif
1757		1757
1758	#ifdef ATTACK_DEBUG	1758	#ifdef ATTACK_DEBUG
1759	LOG(llevDebug,"Friendly fire (type:%d setting: %d%) did %d damage dropped to %d\n",	1759	LOG(llevDebug,"Friendly fire (type:%d setting: %d%) did %d damage dropped to %d\n",
1760	friendlyfire, settings.set_friendly_fire, dam, maxdam);	1760	friendlyfire, settings.set_friendly_fire, dam, maxdam);
1761	#endif	1761	#endif
1762	}	1762	}
1763		1763
1764	if (!full_hit) {	1764	if (!full_hit) {
1765	archetype *at;	1765	archetype *at;
1766	int area;	1766	int area;
1767	int remainder;	1767	int remainder;
1768		1768
1769	area = 0;	1769	area = 0;
1770	for(at = op->arch; at != NULL; at = at->more)	1770	for(at = op->arch; at != NULL; at = at->more)
1771	area++;	1771	area++;
1772	assert(area > 0);	1772	assert(area > 0);
1773		1773
1774	/* basically: maxdam /= area; we try to "simulate" a float	1774	/* basically: maxdam /= area; we try to "simulate" a float
1775	value-effect */	1775	value-effect */
1776	remainder = 100*(maxdam%area)/area;	1776	remainder = 100*(maxdam%area)/area;
1777	maxdam /= area;	1777	maxdam /= area;
1778	if (RANDOM()%100 < remainder)	1778	if (RANDOM()%100 < remainder)
1779	maxdam++;	1779	maxdam++;
1780	}	1780	}
1781		1781
1782	#ifdef ATTACK_DEBUG	1782	#ifdef ATTACK_DEBUG
1783	LOG(llevDebug,"Attacktype %d did %d damage\n", type, maxdam);	1783	LOG(llevDebug,"Attacktype %d did %d damage\n", type, maxdam);
1784	#endif	1784	#endif
1785		1785
1786	if(get_owner(hitter))	1786	if(get_owner(hitter))
1787	op->enemy=hitter->owner;	1787	op->enemy=hitter->owner;
1788	else if (QUERY_FLAG(hitter,FLAG_ALIVE))	1788	else if (QUERY_FLAG(hitter,FLAG_ALIVE))
1789	op->enemy=hitter;	1789	op->enemy=hitter;
1790		1790
1791	if(QUERY_FLAG(op,FLAG_UNAGGRESSIVE) && op->type != PLAYER) {	1791	if(QUERY_FLAG(op,FLAG_UNAGGRESSIVE) && op->type != PLAYER) {
1792	/* The unaggressives look after themselves 8) */	1792	/* The unaggressives look after themselves 8) */
1793	CLEAR_FLAG(op, FLAG_UNAGGRESSIVE);	1793	CLEAR_FLAG(op, FLAG_UNAGGRESSIVE);
1794	npc_call_help(op);	1794	npc_call_help(op);
1795	}	1795	}
1796		1796
1797	if (magic && did_make_save(op, op->level, 0))	1797	if (magic && did_make_save(op, op->level, 0))
1798	maxdam=maxdam/2;	1798	maxdam=maxdam/2;
1799		1799
1800	attack_message(maxdam, maxattacktype, op, hitter);	1800	attack_message(maxdam, maxattacktype, op, hitter);
1801		1801
1802	op->stats.hp-=maxdam;	1802	op->stats.hp-=maxdam;
1803		1803
1804	/* Eneq(@csd.uu.se): Check to see if monster runs away. */	1804	/* Eneq(@csd.uu.se): Check to see if monster runs away. */
1805	if ((op->stats.hp>=0) &&	1805	if ((op->stats.hp>=0) &&
1806	(QUERY_FLAG(op, FLAG_MONSTER) || op->type == PLAYER) &&	1806	(QUERY_FLAG(op, FLAG_MONSTER) || op->type == PLAYER) &&
1807	op->stats.hp<(signed short)(((float)op->run_away/(float)100)*	1807	op->stats.hp<(signed short)(((float)op->run_away/(float)100)*
1808	(float)op->stats.maxhp)) {	1808	(float)op->stats.maxhp)) {
1809		1809
1810	if (QUERY_FLAG(op, FLAG_MONSTER))	1810	if (QUERY_FLAG(op, FLAG_MONSTER))
1811	SET_FLAG(op, FLAG_RUN_AWAY);	1811	SET_FLAG(op, FLAG_RUN_AWAY);
1812	else	1812	else
1813	scare_creature(op, hitter);	1813	scare_creature(op, hitter);
1814	}	1814	}
1815		1815
1816	if(QUERY_FLAG(op,FLAG_TEAR_DOWN)) {	1816	if(QUERY_FLAG(op,FLAG_TEAR_DOWN)) {
1817	if (maxdam)	1817	if (maxdam)
1818	tear_down_wall(op);	1818	tear_down_wall(op);
1819	return maxdam; /* nothing more to do for wall */	1819	return maxdam; /* nothing more to do for wall */
1820	}	1820	}
1821		1821
1822	/* See if the creature has been killed */	1822	/* See if the creature has been killed */
1823	rtn_kill = kill_object(op, maxdam, hitter, type);	1823	rtn_kill = kill_object(op, maxdam, hitter, type);
1824	if (rtn_kill != -1)	1824	if (rtn_kill != -1)
1825	return rtn_kill;	1825	return rtn_kill;
1826		1826
1827		1827
1828	/* Used to be ghosthit removal - we now use the ONE_HIT flag. Note	1828	/* Used to be ghosthit removal - we now use the ONE_HIT flag. Note
1829	* that before if the player was immune to ghosthit, the monster	1829	* that before if the player was immune to ghosthit, the monster
1830	* remained - that is no longer the case.	1830	* remained - that is no longer the case.
1831	*/	1831	*/
1832	if(QUERY_FLAG(hitter, FLAG_ONE_HIT)) {	1832	if(QUERY_FLAG(hitter, FLAG_ONE_HIT)) {
1833	if(QUERY_FLAG(hitter,FLAG_FRIENDLY))	1833	if(QUERY_FLAG(hitter,FLAG_FRIENDLY))
1834	remove_friendly_object(hitter);	1834	remove_friendly_object(hitter);
1835	remove_ob(hitter);	1835	remove_ob(hitter);
1836	free_object(hitter);	1836	free_object(hitter);
1837	}	1837	}
1838	/* Lets handle creatures that are splitting now */	1838	/* Lets handle creatures that are splitting now */
1839	else if(type&AT_PHYSICAL&&!QUERY_FLAG(op, FLAG_FREED)&&QUERY_FLAG(op,FLAG_SPLITTING)) {	1839	else if(type&AT_PHYSICAL&&!QUERY_FLAG(op, FLAG_FREED)&&QUERY_FLAG(op,FLAG_SPLITTING)) {
1840	int i;	1840	int i;
1841	int friendly = QUERY_FLAG(op,FLAG_FRIENDLY);	1841	int friendly = QUERY_FLAG(op,FLAG_FRIENDLY);
1842	int unaggressive = QUERY_FLAG(op, FLAG_UNAGGRESSIVE);	1842	int unaggressive = QUERY_FLAG(op, FLAG_UNAGGRESSIVE);
1843	object *owner = get_owner(op);	1843	object *owner = get_owner(op);
1844		1844
1845	if(!op->other_arch) {	1845	if(!op->other_arch) {
1846	LOG(llevError,"SPLITTING without other_arch error.\n");	1846	LOG(llevError,"SPLITTING without other_arch error.\n");
1847	return maxdam;	1847	return maxdam;
1848	}	1848	}
1849	remove_ob(op);	1849	remove_ob(op);
1850	for(i=0;i<NROFNEWOBJS(op);i++) { /* This doesn't handle op->more yet */	1850	for(i=0;i<NROFNEWOBJS(op);i++) { /* This doesn't handle op->more yet */
1851	object *tmp=arch_to_object(op->other_arch);	1851	object *tmp=arch_to_object(op->other_arch);
1852	int j;	1852	int j;
1853		1853
1854	tmp->stats.hp=op->stats.hp;	1854	tmp->stats.hp=op->stats.hp;
1855	if (friendly) {	1855	if (friendly) {
1856	SET_FLAG(tmp, FLAG_FRIENDLY);	1856	SET_FLAG(tmp, FLAG_FRIENDLY);
1857	add_friendly_object(tmp);	1857	add_friendly_object(tmp);
1858	tmp->attack_movement = PETMOVE;	1858	tmp->attack_movement = PETMOVE;
1859	if (owner!=NULL)	1859	if (owner!=NULL)
1860	set_owner(tmp,owner);	1860	set_owner(tmp,owner);
1861	}	1861	}
1862	if (unaggressive)	1862	if (unaggressive)
1863	SET_FLAG(tmp, FLAG_UNAGGRESSIVE);	1863	SET_FLAG(tmp, FLAG_UNAGGRESSIVE);
1864	j=find_first_free_spot(tmp,op->map,op->x,op->y);	1864	j=find_first_free_spot(tmp,op->map,op->x,op->y);
1865	if (j==-1) /* No spot to put this monster */	1865	if (j==-1) /* No spot to put this monster */
1866	free_object(tmp);	1866	free_object(tmp);
1867	else {	1867	else {
1868	tmp->x=op->x+freearr_x[j],tmp->y=op->y+freearr_y[j];	1868	tmp->x=op->x+freearr_x[j],tmp->y=op->y+freearr_y[j];
1869	insert_ob_in_map(tmp,op->map,NULL,0);	1869	insert_ob_in_map(tmp,op->map,NULL,0);
1870	}	1870	}
1871	}	1871	}
1872	if(friendly)	1872	if(friendly)
1873	remove_friendly_object(op);	1873	remove_friendly_object(op);
1874	free_object(op);	1874	free_object(op);
1875	}	1875	}
1876	else if(type & AT_DRAIN && hitter->type==GRIMREAPER&&hitter->value++>10) {	1876	else if(type & AT_DRAIN && hitter->type==GRIMREAPER&&hitter->value++>10) {
1877	remove_ob(hitter);	1877	remove_ob(hitter);
1878	free_object(hitter);	1878	free_object(hitter);
1879	}	1879	}
1880	return maxdam;	1880	return maxdam;
1881	}	1881	}
1882		1882
1883		1883
…		…
1885	{	1885	{
1886	archetype *at = find_archetype("poisoning");	1886	archetype *at = find_archetype("poisoning");
1887	object *tmp=present_arch_in_ob(at,op);	1887	object *tmp=present_arch_in_ob(at,op);
1888		1888
1889	if(tmp==NULL) {	1889	if(tmp==NULL) {
1890	if((tmp=arch_to_object(at))==NULL)	1890	if((tmp=arch_to_object(at))==NULL)
1891	LOG(llevError,"Failed to clone arch poisoning.\n");	1891	LOG(llevError,"Failed to clone arch poisoning.\n");
1892	else {	1892	else {
1893	tmp = insert_ob_in_ob(tmp,op);	1893	tmp = insert_ob_in_ob(tmp,op);
1894	/* peterm: give poisoning some teeth. It should	1894	/* peterm: give poisoning some teeth. It should
1895	* be able to kill things better than it does:	1895	* be able to kill things better than it does:
1896	* damage should be dependent something--I choose to	1896	* damage should be dependent something--I choose to
1897	* do this: if it's a monster, the damage from the	1897	* do this: if it's a monster, the damage from the
1898	* poisoning goes as the level of the monster/2.	1898	* poisoning goes as the level of the monster/2.
1899	* If anything else, goes as damage.	1899	* If anything else, goes as damage.
1900	*/	1900	*/
1901		1901
1902	if(QUERY_FLAG(hitter,FLAG_ALIVE))	1902	if(QUERY_FLAG(hitter,FLAG_ALIVE))
1903	tmp->stats.dam += hitter->level/2;	1903	tmp->stats.dam += hitter->level/2;
1904	else	1904	else
1905	tmp->stats.dam = dam;	1905	tmp->stats.dam = dam;
1906		1906
1907	copy_owner(tmp,hitter); /* so we get credit for poisoning kills */	1907	copy_owner(tmp,hitter); /* so we get credit for poisoning kills */
1908	if(hitter->skill && hitter->skill != tmp->skill) {	1908	if(hitter->skill && hitter->skill != tmp->skill) {
1909	if (tmp->skill) free_string(tmp->skill);	1909	if (tmp->skill) free_string(tmp->skill);
1910	tmp->skill = add_refcount(hitter->skill);	1910	tmp->skill = add_refcount(hitter->skill);
1911	}	1911	}
1912		1912
1913	tmp->stats.food+=dam; /* more damage, longer poisoning */	1913	tmp->stats.food+=dam; /* more damage, longer poisoning */
1914		1914
1915	if(op->type==PLAYER) {	1915	if(op->type==PLAYER) {
1916	/* player looses stats, maximum is -10 of each */	1916	/* player looses stats, maximum is -10 of each */
1917	tmp->stats.Con= MAX(-(dam/4+1), -10);	1917	tmp->stats.Con= MAX(-(dam/4+1), -10);
1918	tmp->stats.Str= MAX(-(dam/3+2), -10);	1918	tmp->stats.Str= MAX(-(dam/3+2), -10);
1919	tmp->stats.Dex= MAX(-(dam/6+1), -10);	1919	tmp->stats.Dex= MAX(-(dam/6+1), -10);
1920	tmp->stats.Int= MAX(-dam/7, -10);	1920	tmp->stats.Int= MAX(-dam/7, -10);
1921	SET_FLAG(tmp,FLAG_APPLIED);	1921	SET_FLAG(tmp,FLAG_APPLIED);
1922	fix_player(op);	1922	fix_player(op);
1923	new_draw_info(NDI_UNIQUE, 0,op,"You suddenly feel very ill.");	1923	new_draw_info(NDI_UNIQUE, 0,op,"You suddenly feel very ill.");
1924	}	1924	}
1925	if (hitter->type == PLAYER)	1925	if (hitter->type == PLAYER)
1926	new_draw_info_format(NDI_UNIQUE, 0, hitter, "You poison %s.",	1926	new_draw_info_format(NDI_UNIQUE, 0, hitter, "You poison %s.",
1927	op->name);	1927	op->name);
1928	else if (get_owner(hitter) != NULL && hitter->owner->type == PLAYER)	1928	else if (get_owner(hitter) != NULL && hitter->owner->type == PLAYER)
1929	new_draw_info_format(NDI_UNIQUE, 0, hitter->owner,	1929	new_draw_info_format(NDI_UNIQUE, 0, hitter->owner,
1930	"Your %s poisons %s.", hitter->name, op->name);	1930	"Your %s poisons %s.", hitter->name, op->name);
1931	}	1931	}
1932	tmp->speed_left=0;	1932	tmp->speed_left=0;
1933	}	1933	}
1934	else	1934	else
1935	tmp->stats.food++;	1935	tmp->stats.food++;
1936	}	1936	}
1937		1937
1938	void slow_player(object *op,object *hitter,int dam)	1938	void slow_player(object *op,object *hitter,int dam)
1939	{ archetype *at = find_archetype("slowness");	1939	{ archetype *at = find_archetype("slowness");
1940	object *tmp;	1940	object *tmp;
…		…
1957	object *tmp;	1957	object *tmp;
1958	int maxduration;	1958	int maxduration;
1959		1959
1960	tmp = present_in_ob_by_name(FORCE,"confusion", op);	1960	tmp = present_in_ob_by_name(FORCE,"confusion", op);
1961	if(!tmp) {	1961	if(!tmp) {
1962	tmp = get_archetype(FORCE_NAME);	1962	tmp = get_archetype(FORCE_NAME);
1963	tmp = insert_ob_in_ob(tmp,op);	1963	tmp = insert_ob_in_ob(tmp,op);
1964	}	1964	}
1965		1965
1966	/* Duration added per hit and max. duration of confusion both depend	1966	/* Duration added per hit and max. duration of confusion both depend
1967	* on the player's resistance	1967	* on the player's resistance
1968	*/	1968	*/
…		…
1971	tmp->duration = 8 + MAX(1, 5*(100-op->resist[ATNR_CONFUSION])/100);	1971	tmp->duration = 8 + MAX(1, 5*(100-op->resist[ATNR_CONFUSION])/100);
1972	if (tmp->name) free_string(tmp->name);	1972	if (tmp->name) free_string(tmp->name);
1973	tmp->name = add_string("confusion");	1973	tmp->name = add_string("confusion");
1974	maxduration = MAX(2, 30*(100-op->resist[ATNR_CONFUSION])/100);	1974	maxduration = MAX(2, 30*(100-op->resist[ATNR_CONFUSION])/100);
1975	if( tmp->duration > maxduration)	1975	if( tmp->duration > maxduration)
1976	tmp->duration = maxduration;	1976	tmp->duration = maxduration;
1977		1977
1978	if(op->type == PLAYER && !QUERY_FLAG(op,FLAG_CONFUSED))	1978	if(op->type == PLAYER && !QUERY_FLAG(op,FLAG_CONFUSED))
1979	new_draw_info(NDI_UNIQUE, 0,op,"You suddenly feel very confused!");	1979	new_draw_info(NDI_UNIQUE, 0,op,"You suddenly feel very confused!");
1980	SET_FLAG(op, FLAG_CONFUSED);	1980	SET_FLAG(op, FLAG_CONFUSED);
1981	}	1981	}
1982		1982
1983	void blind_player(object *op, object *hitter, int dam)	1983	void blind_player(object *op, object *hitter, int dam)
1984	{	1984	{
…		…
2003		2003
2004	if(hitter->owner) owner = get_owner(hitter);	2004	if(hitter->owner) owner = get_owner(hitter);
2005	else owner = hitter;	2005	else owner = hitter;
2006		2006
2007	new_draw_info_format(NDI_UNIQUE,0,owner,	2007	new_draw_info_format(NDI_UNIQUE,0,owner,
2008	"Your attack blinds %s!",query_name(op));	2008	"Your attack blinds %s!",query_name(op));
2009	}	2009	}
2010	tmp->stats.food += dam;	2010	tmp->stats.food += dam;
2011	if(tmp->stats.food > 10) tmp->stats.food = 10;	2011	if(tmp->stats.food > 10) tmp->stats.food = 10;
2012	}	2012	}
2013		2013
…		…
2020	* written? Well, i think this can and should be removed	2020	* written? Well, i think this can and should be removed
2021	*/	2021	*/
2022		2022
2023	/*	2023	/*
2024	if((tmp=present(PARAIMAGE,op->map,op->x,op->y))==NULL) {	2024	if((tmp=present(PARAIMAGE,op->map,op->x,op->y))==NULL) {
2025	tmp=clone_arch(PARAIMAGE);	2025	tmp=clone_arch(PARAIMAGE);
2026	tmp->x=op->x,tmp->y=op->y;	2026	tmp->x=op->x,tmp->y=op->y;
2027	insert_ob_in_map(tmp,op->map,tmp,INS_NO_MERGE | INS_NO_WALK_ON);	2027	insert_ob_in_map(tmp,op->map,tmp,INS_NO_MERGE | INS_NO_WALK_ON);
2028	}	2028	}
2029	*/	2029	*/
2030		2030
2031	/* Do this as a float - otherwise, rounding might very well reduce this to 0 */	2031	/* Do this as a float - otherwise, rounding might very well reduce this to 0 */
2032	effect = (float)dam * 3.0 * (100.0 - op->resist[ATNR_PARALYZE]) / 100;	2032	effect = (float)dam * 3.0 * (100.0 - op->resist[ATNR_PARALYZE]) / 100;
…		…
2059	** field of the deathstriking object */	2059	** field of the deathstriking object */
2060		2060
2061	int atk_lev, def_lev, kill_lev;	2061	int atk_lev, def_lev, kill_lev;
2062		2062
2063	if(hitter->slaying)	2063	if(hitter->slaying)
2064	if(!( (QUERY_FLAG(op,FLAG_UNDEAD)&&strstr(hitter->slaying,undead_name)) ||	2064	if(!( (QUERY_FLAG(op,FLAG_UNDEAD)&&strstr(hitter->slaying,undead_name)) ||
2065	(op->race&&strstr(hitter->slaying,op->race)))) return;	2065	(op->race&&strstr(hitter->slaying,op->race)))) return;
2066		2066
2067	def_lev = op->level;	2067	def_lev = op->level;
2068	if (def_lev < 1) {	2068	if (def_lev < 1) {
2069	LOG (llevError, "BUG: arch %s, name %s with level < 1\n",	2069	LOG (llevError, "BUG: arch %s, name %s with level < 1\n",
2070	op->arch->name, op->name);	2070	op->arch->name, op->name);
…		…
2073	atk_lev = (hitter->chosen_skill?hitter->chosen_skill->level:hitter->level) / 2;	2073	atk_lev = (hitter->chosen_skill?hitter->chosen_skill->level:hitter->level) / 2;
2074	/* LOG(llevDebug,"Deathstrike - attack level %d, defender level %d\n",	2074	/* LOG(llevDebug,"Deathstrike - attack level %d, defender level %d\n",
2075	atk_lev, def_lev); */	2075	atk_lev, def_lev); */
2076		2076
2077	if(atk_lev >= def_lev ){	2077	if(atk_lev >= def_lev ){
2078	kill_lev = random_roll(0, atk_lev-1, hitter, PREFER_HIGH);	2078	kill_lev = random_roll(0, atk_lev-1, hitter, PREFER_HIGH);
2079		2079
2080	/* Note that the below effectively means the ratio of the atk vs	2080	/* Note that the below effectively means the ratio of the atk vs
2081	* defener level is important - if level 52 character has very little	2081	* defener level is important - if level 52 character has very little
2082	* chance of killing a level 50 monster. This should probably be	2082	* chance of killing a level 50 monster. This should probably be
2083	* redone.	2083	* redone.
2084	*/	2084	*/
2085	if(kill_lev >= def_lev) {	2085	if(kill_lev >= def_lev) {
2086	*dam = op->stats.hp+10; /* take all hp. they can still save for 1/2 */	2086	*dam = op->stats.hp+10; /* take all hp. they can still save for 1/2 */
2087	/* I think this doesn't really do much. Because of	2087	/* I think this doesn't really do much. Because of
2088	* integer rounding, this only makes any difference if the	2088	* integer rounding, this only makes any difference if the
2089	* attack level is double the defender level.	2089	* attack level is double the defender level.
2090	*/	2090	*/
2091	*dam *= kill_lev / def_lev;	2091	*dam *= kill_lev / def_lev;
2092	}	2092	}
2093	} else {	2093	} else {
2094	*dam = 0; /* no harm done */	2094	*dam = 0; /* no harm done */
2095	}	2095	}
2096	}	2096	}
2097		2097
…		…
2100	* monster).	2100	* monster).
2101	*/	2101	*/
2102	static void thrown_item_effect (object *hitter, object *victim)	2102	static void thrown_item_effect (object *hitter, object *victim)
2103	{	2103	{
2104	if(!QUERY_FLAG(hitter,FLAG_ALIVE)) {	2104	if(!QUERY_FLAG(hitter,FLAG_ALIVE)) {
2105	/* May not need a switch for just 2 types, but this makes it	2105	/* May not need a switch for just 2 types, but this makes it
2106	* easier for expansion.	2106	* easier for expansion.
2107	*/	2107	*/
2108	switch (hitter->type) {	2108	switch (hitter->type) {
2109	case POTION:	2109	case POTION:
2110	/* should player get a save throw instead of checking magic protection? */	2110	/* should player get a save throw instead of checking magic protection? */
2111	if(QUERY_FLAG(victim,FLAG_ALIVE)&&!QUERY_FLAG(victim,FLAG_UNDEAD)	2111	if(QUERY_FLAG(victim,FLAG_ALIVE)&&!QUERY_FLAG(victim,FLAG_UNDEAD)
2112	&&(victim->resist[ATNR_MAGIC]<60)) (void) apply_potion(victim,hitter);	2112	&&(victim->resist[ATNR_MAGIC]<60)) (void) apply_potion(victim,hitter);
2113	break;	2113	break;
2114		2114
2115	case POISON: /* poison drinks */	2115	case POISON: /* poison drinks */
2116	/* As with potions, should monster get a save? */	2116	/* As with potions, should monster get a save? */
2117	if(QUERY_FLAG(victim,FLAG_ALIVE)&&!QUERY_FLAG(victim,FLAG_UNDEAD)	2117	if(QUERY_FLAG(victim,FLAG_ALIVE)&&!QUERY_FLAG(victim,FLAG_UNDEAD)
2118	&&(victim->resist[ATNR_POISON]<60)) apply_poison(victim,hitter);	2118	&&(victim->resist[ATNR_POISON]<60)) apply_poison(victim,hitter);
2119	break;	2119	break;
2120		2120
2121	/* Removed case statements that did nothing.	2121	/* Removed case statements that did nothing.
2122	* food may be poisonous, but monster must be willing to eat it,	2122	* food may be poisonous, but monster must be willing to eat it,
2123	* so we don't handle it here.	2123	* so we don't handle it here.
2124	* Containers should perhaps break open, but that code was disabled.	2124	* Containers should perhaps break open, but that code was disabled.
2125	*/	2125	*/
2126	}	2126	}
2127	}	2127	}
2128	}	2128	}
2129		2129
2130	/* adj_attackroll() - adjustments to attacks by various conditions */	2130	/* adj_attackroll() - adjustments to attacks by various conditions */
2131		2131
…		…
2203		2203
2204	/* I broke what used to be one big if into a few nested	2204	/* I broke what used to be one big if into a few nested
2205	* ones so that figuring out the logic is at least possible.	2205	* ones so that figuring out the logic is at least possible.
2206	*/	2206	*/
2207	if (op && (op->move_type & MOVE_FLYING)) {	2207	if (op && (op->move_type & MOVE_FLYING)) {
2208	if (op->type==ARROW || op->type==THROWN_OBJ)	2208	if (op->type==ARROW || op->type==THROWN_OBJ)
2209	return 1;	2209	return 1;
2210	else if (op->type==SPELL_EFFECT && (op->subtype == SP_BULLET ||	2210	else if (op->type==SPELL_EFFECT && (op->subtype == SP_BULLET ||
2211	op->subtype == SP_EXPLOSION))	2211	op->subtype == SP_EXPLOSION))
2212	return 1;	2212	return 1;
2213	}	2213	}
2214	return 0;	2214	return 0;
2215	}	2215	}
2216		2216

Diff Legend

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