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.3 by root, Sat Aug 26 23:36:33 2006 UTC vs.
Revision 1.8 by root, Sun Sep 3 00:18:42 2006 UTC

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

Diff Legend

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