ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/attack.C

Comparing deliantra/server/server/attack.C (file contents):
Revision 1.4 by root, Tue Aug 29 07:34:00 2006 UTC vs.
Revision 1.6 by elmex, Tue Aug 29 11:58:02 2006 UTC

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

Diff Legend

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