ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/attack.C
Revision: 1.22
Committed: Fri Sep 29 11:53:09 2006 UTC (17 years, 7 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.21: +1 -1 lines
Log Message:
enlarge killer and other fields, do not use silly BIG_NAME with no meaning.

File Contents

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