Crossfire Server, Trunk  R20708
attack.c
Go to the documentation of this file.
1 /*
2  * Crossfire -- cooperative multi-player graphical RPG and adventure game
3  *
4  * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
5  * Copyright (c) 1992 Frank Tore Johansen
6  *
7  * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
8  * welcome to redistribute it under certain conditions. For details, please
9  * see COPYING and LICENSE.
10  *
11  * The authors can be reached via e-mail at <crossfire@metalforge.org>.
12  */
13 
21 #include "global.h"
22 
23 #include <assert.h>
24 #include <stdlib.h>
25 #include <string.h>
26 
27 #include "living.h"
28 #include "material.h"
29 #include "skills.h"
30 #include "sounds.h"
31 #include "sproto.h"
32 
33 /*#define ATTACK_DEBUG*/
34 
35 static void slow_living(object *op, object *hitter, int dam);
36 static void deathstrike_living(object *op, object *hitter, int *dam);
37 static int adj_attackroll(object *hitter, object *target);
38 static int is_aimed_missile(object *op);
39 static int did_make_save_item(object *op, int type, object *originator);
40 static void poison_living(object *op, object *hitter, int dam);
41 
49 static void cancellation(object *op) {
50  if (op->invisible)
51  return;
52 
53  if (QUERY_FLAG(op, FLAG_ALIVE) || op->type == CONTAINER || op->type == THROWN_OBJ) {
54  /* Recur through the inventory */
55  FOR_INV_PREPARE(op, inv)
56  if (!did_make_save_item(inv, AT_CANCELLATION, op))
57  cancellation(inv);
58  FOR_INV_FINISH();
59  } else if (FABS(op->magic) <= rndm(0, 5)) {
60  /* Nullify this object. This code could probably be more complete */
61  /* in what abilities it should cancel */
62  op->magic = 0;
63  CLEAR_FLAG(op, FLAG_DAMNED);
64  CLEAR_FLAG(op, FLAG_CURSED);
65  CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL);
66  CLEAR_FLAG(op, FLAG_KNOWN_CURSED);
67  if (op->env && op->env->type == PLAYER) {
68  esrv_update_item(UPD_FLAGS, op->env, op);
69  }
70  }
71 }
72 
88 static int did_make_save_item(object *op, int type, object *originator) {
89  int i, roll, saves = 0, attacks = 0, number;
90  materialtype_t *mt;
91 
92  if (op->materialname == NULL) {
93  for (mt = materialt; mt != NULL && mt->next != NULL; mt = mt->next) {
94  if (op->material&mt->material)
95  break;
96  }
97  } else
98  mt = name_to_material(op->materialname);
99  if (mt == NULL)
100  return TRUE;
101  roll = rndm(1, 20);
102 
103  /* the attacktypes have no meaning for object saves
104  * If the type is only magic, don't adjust type - basically, if
105  * pure magic is hitting an object, it should save. However, if it
106  * is magic teamed with something else, then strip out the
107  * magic type, and instead let the fire, cold, or whatever component
108  * destroy the item. Otherwise, you get the case of poisoncloud
109  * destroying objects because it has magic attacktype.
110  */
111  if (type != AT_MAGIC)
112  type &= ~(AT_CONFUSION|AT_DRAIN|AT_GHOSTHIT|AT_POISON|AT_SLOW|
113  AT_PARALYZE|AT_TURN_UNDEAD|AT_FEAR|AT_DEPLETE|AT_DEATH|
114  AT_COUNTERSPELL|AT_HOLYWORD|AT_BLIND|AT_LIFE_STEALING|
115  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  i = 1<<number;
126  if (!(i&type))
127  continue;
128  attacks++;
129  if (op->resist[number] == 100)
130  saves++;
131  else if (roll >= mt->save[number]-op->magic-op->resist[number]/100)
132  saves++;
133  else if ((20-mt->save[number])/3 > originator->stats.dam)
134  saves++;
135  }
136 
137  if (saves == attacks || attacks == 0)
138  return TRUE;
139  if (saves == 0 || rndm(1, attacks) > saves)
140  return FALSE;
141  return TRUE;
142 }
143 
156 void save_throw_object(object *op, uint32_t type, object *originator) {
157  int dam;
158 
159  if (!did_make_save_item(op, type, originator)) {
160  object *env = op->env;
161  int x = op->x, y = op->y;
162  mapstruct *m = op->map;
163  /* For use with burning off equipped items */
164  int weight = op->weight;
165 
166  op = stop_item(op);
167  if (op == NULL)
168  return;
169 
170  /*
171  * If this object is a transport and has players in it, make them disembark.
172  */
173  if (op->type == TRANSPORT && op->inv) {
174  if (op->map == NULL) {
175  LOG(llevError, "Transport %s not on a map but with an item %s in it?\n", op->name, op->inv->name);
176  } else {
177  char name[MAX_BUF];
178  query_name(op, name, sizeof(name));
179  FOR_INV_PREPARE(op, inv) {
180  if (inv->contr) {
181  draw_ext_info_format(NDI_UNIQUE, 0, inv, MSG_TYPE_APPLY, MSG_TYPE_APPLY_UNAPPLY,
182  "You are expelled from the %s during its destruction.",
183  name);
184  inv->contr->transport = NULL;
185  }
186  }
187  FOR_INV_FINISH();
188  }
189  }
190 
191 
192  /* Set off runes in the inventory of the object being destroyed. */
193  FOR_INV_PREPARE(op, inv)
194  if (inv->type == RUNE)
195  spring_trap(inv, originator);
196  FOR_INV_FINISH();
197 
198  /* Hacked the following so that type LIGHTER will work.
199  * Also, objects which are potenital "lights" that are hit by
200  * flame/elect attacks will be set to glow. "lights" are any
201  * object with +/- glow_radius and an "other_arch" to change to.
202  * (and please note that we cant fail our save and reach this
203  * function if the object doesnt contain a material that can burn.
204  * So forget lighting magical swords on fire with this!) -b.t.
205  */
206  if (type&(AT_FIRE|AT_ELECTRICITY)
207  && op->other_arch
208  && QUERY_FLAG(op, FLAG_IS_LIGHTABLE)) {
209  const char *arch = op->other_arch->name;
210 
211  op = object_decrease_nrof(op, 1);
212  if (op)
213  fix_stopped_item(op, m, originator);
214  op = create_archetype(arch);
215  if (op != NULL) {
216  if (env) {
217  op->x = env->x,
218  op->y = env->y;
219  object_insert_in_ob(op, env);
220  } else
221  object_insert_in_map_at(op, m, originator, 0, x, y);
222  }
223  return;
224  }
225  if (type&AT_CANCELLATION) { /* Cancellation. */
226  cancellation(op);
227  fix_stopped_item(op, m, originator);
228  return;
229  }
230  if (op->nrof > 1) {
231  op = object_decrease_nrof(op, rndm(0, op->nrof-1));
232  if (op)
233  fix_stopped_item(op, m, originator);
234  } else {
235  if (!QUERY_FLAG(op, FLAG_REMOVED))
236  object_remove(op);
237  object_free_drop_inventory(op);
238  }
239  if (type&(AT_FIRE|AT_ELECTRICITY)) {
240  if (env) {
241  /* Check to see if the item being burnt is being worn */
242  if (QUERY_FLAG(op, FLAG_APPLIED)) {
243  /* if the object is applied, it should be safe to assume env is a player or creature. */
244  if (env->resist[ATNR_FIRE] < 100)
245  /* Should the message type be something different? */
246  draw_ext_info_format(NDI_RED, 0, env, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
247  "OUCH! It burns!");
248  else
249  draw_ext_info_format(NDI_UNIQUE, 0, env, MSG_TYPE_APPLY, MSG_TYPE_APPLY_SUCCESS,
250  "Despite the flame, you feel nothing.");
251  /* burning off an item causes 1 point of fire damage for every kilogram of mass the item has */
252  dam = weight / 1000 * (100 - env->resist[ATNR_FIRE]) / 100;
253  /* Double the damage on cursed items */
254  if (QUERY_FLAG(op, FLAG_CURSED))
255  dam *= 2;
256  /* Triple the damage on damned items. A cursed and damned item would thus inflict 6x damage. */
257  if (QUERY_FLAG(op, FLAG_DAMNED))
258  dam *= 3;
259  env->stats.hp -= dam;
260  /* You die at -1, not 0 */
261  if (env->stats.hp < 0)
262  kill_player(env, NULL);
263  }
264  op = create_archetype("burnout");
265  op->x = env->x,
266  op->y = env->y;
267  object_insert_in_ob(op, env);
268  } else {
269  object_replace_insert_in_map("burnout", originator);
270  }
271  }
272  return;
273  }
274  /* The value of 50 is arbitrary. */
275  if (type&AT_COLD
276  && (op->resist[ATNR_COLD] < 50)
277  && !QUERY_FLAG(op, FLAG_NO_PICK)
278  && (RANDOM()&2)) {
279  object *tmp;
280  archetype *at = find_archetype("icecube");
281 
282  if (at == NULL)
283  return;
284  op = stop_item(op);
285  if (op == NULL)
286  return;
287  tmp = map_find_by_archetype(op->map, op->x, op->y, at);
288  if (tmp == NULL) {
289  tmp = arch_to_object(at);
290  /* This was in the old (pre new movement code) -
291  * icecubes have slow_move set to 1 - don't want
292  * that for ones we create.
293  */
294  tmp->move_slow_penalty = 0;
295  tmp->move_slow = 0;
296  object_insert_in_map_at(tmp, op->map, originator, 0, op->x, op->y);
297  }
298  if (!QUERY_FLAG(op, FLAG_REMOVED))
299  object_remove(op);
300  (void)object_insert_in_ob(op, tmp);
301  return;
302  }
303 }
304 
320 int hit_map(object *op, int dir, uint32_t type, int full_hit) {
321  mapstruct *map;
322  int16_t x, y;
323  int retflag = 0; /* added this flag.. will return 1 if it hits a monster */
324  tag_t op_tag;
325 
326  if (QUERY_FLAG(op, FLAG_FREED)) {
327  LOG(llevError, "BUG: hit_map(): free object\n");
328  return 0;
329  }
330 
331  if (QUERY_FLAG(op, FLAG_REMOVED) || op->env != NULL) {
332  LOG(llevError, "BUG: hit_map(): hitter (arch %s, name %s) not on a map\n", op->arch->name, op->name);
333  return 0;
334  }
335 
336  if (!op->map) {
337  LOG(llevError, "BUG: hit_map(): %s has no map\n", op->name);
338  return 0;
339  }
340 
341  op = HEAD(op);
342  op_tag = op->count;
343 
344  map = op->map;
345  x = op->x+freearr_x[dir];
346  y = op->y+freearr_y[dir];
347  if (get_map_flags(map, &map, x, y, &x, &y)&P_OUT_OF_MAP)
348  return 0;
349 
350  /* peterm: a few special cases for special attacktypes --counterspell
351  * must be out here because it strikes things which are not alive
352  */
353 
354  if (type&AT_COUNTERSPELL) {
355  counterspell(op, dir); /* see spell_effect.c */
356 
357  /* If the only attacktype is counterspell or magic, don't need
358  * to do any further processing.
359  */
360  if (!(type&~(AT_COUNTERSPELL|AT_MAGIC))) {
361  return 0;
362  }
363  type &= ~AT_COUNTERSPELL;
364  }
365 
366  if (type&AT_CHAOS) {
367  shuffle_attack(op, 1); /*1 flag tells it to change the face */
368  object_update(op, UP_OBJ_FACE);
369  type &= ~AT_CHAOS;
370  }
371 
372  FOR_MAP_PREPARE(map, x, y, tmp) {
373  if (QUERY_FLAG(tmp, FLAG_FREED)) {
374  LOG(llevError, "BUG: hit_map(): found freed object\n");
375  break;
376  }
377 
378  /* Something could have happened to 'tmp' while 'tmp->below' was processed.
379  * For example, 'tmp' was put in an icecube.
380  * This is one of the few cases where on_same_map should not be used.
381  */
382  if (tmp->map != map || tmp->x != x || tmp->y != y)
383  continue;
384 
385  tmp = HEAD(tmp);
386 
387  /* Need to hit everyone in the transport with this spell */
388  if (tmp->type == TRANSPORT) {
389  FOR_INV_PREPARE(tmp, pl)
390  if (pl->type == PLAYER)
391  hit_player(pl, op->stats.dam, op, type, full_hit);
392  FOR_INV_FINISH();
393  }
394 
395  if (QUERY_FLAG(tmp, FLAG_ALIVE)) {
396  hit_player(tmp, op->stats.dam, op, type, full_hit);
397  retflag |= 1;
398  if (object_was_destroyed(op, op_tag))
399  break;
400  }
401  /* Here we are potentially destroying an object. If the object has
402  * NO_PASS set, it is also immune - you can't destroy walls. Note
403  * that weak walls have is_alive set, which prevent objects from
404  * passing over/through them. We don't care what type of movement
405  * the wall blocks - if it blocks any type of movement, can't be
406  * destroyed right now.
407  */
408  else if ((tmp->material || tmp->materialname) && op->stats.dam > 0 && !tmp->move_block) {
409  save_throw_object(tmp, type, op);
410  if (object_was_destroyed(op, op_tag))
411  break;
412  }
413  } FOR_MAP_FINISH();
414  return 0;
415 }
416 
432 static void attack_message(int dam, int type, object *op, object *hitter) {
433  char buf[MAX_BUF], buf1[MAX_BUF], buf2[MAX_BUF];
434  int i, found = 0;
435  mapstruct *map;
436  object *owner;
437 
438  /* put in a few special messages for some of the common attacktypes
439  * a player might have. For example, fire, electric, cold, etc
440  * [garbled 20010919]
441  */
442 
443  if (dam == 9998 && op->type == DOOR) {
444  snprintf(buf1, sizeof(buf1), "unlock %s", op->name);
445  snprintf(buf2, sizeof(buf2), " unlocks");
446  found++;
447  }
448  if (dam < 0) {
449  snprintf(buf1, sizeof(buf1), "hit %s", op->name);
450  snprintf(buf2, sizeof(buf2), " hits");
451  found++;
452  } else if (dam == 0) {
453  snprintf(buf1, sizeof(buf1), "missed %s", op->name);
454  snprintf(buf2, sizeof(buf2), " misses");
455  found++;
456  } else if ((hitter->type == DISEASE
457  || hitter->type == SYMPTOM
458  || hitter->type == POISONING
459  || (type&AT_POISON && IS_LIVE(op))) && !found) {
460  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_SUFFER][i].level != -1; i++)
461  if (dam < attack_mess[ATM_SUFFER][i].level
462  || attack_mess[ATM_SUFFER][i+1].level == -1) {
463  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_SUFFER][i].buf1, op->name, attack_mess[ATM_SUFFER][i].buf2);
464  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_SUFFER][i].buf3);
465  found++;
466  break;
467  }
468  } else if (op->type == DOOR && !found) {
469  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_DOOR][i].level != -1; i++)
470  if (dam < attack_mess[ATM_DOOR][i].level
471  || attack_mess[ATM_DOOR][i+1].level == -1) {
472  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_DOOR][i].buf1, op->name, attack_mess[ATM_DOOR][i].buf2);
473  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_DOOR][i].buf3);
474  found++;
475  break;
476  }
477  } else if (hitter->type == PLAYER && IS_LIVE(op)) {
478  if (USING_SKILL(hitter, SK_KARATE)) {
479  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_KARATE][i].level != -1; i++)
480  if (dam < attack_mess[ATM_KARATE][i].level
481  || attack_mess[ATM_KARATE][i+1].level == -1) {
482  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_KARATE][i].buf1, op->name, attack_mess[ATM_KARATE][i].buf2);
483  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_KARATE][i].buf3);
484  found++;
485  break;
486  }
487  } else if (USING_SKILL(hitter, SK_CLAWING)) {
488  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_CLAW][i].level != -1; i++)
489  if (dam < attack_mess[ATM_CLAW][i].level
490  || attack_mess[ATM_CLAW][i+1].level == -1) {
491  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_CLAW][i].buf1, op->name, attack_mess[ATM_CLAW][i].buf2);
492  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_CLAW][i].buf3);
493  found++;
494  break;
495  }
496  } else if (USING_SKILL(hitter, SK_PUNCHING)) {
497  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_PUNCH][i].level != -1; i++)
498  if (dam < attack_mess[ATM_PUNCH][i].level
499  || attack_mess[ATM_PUNCH][i+1].level == -1) {
500  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_PUNCH][i].buf1, op->name, attack_mess[ATM_PUNCH][i].buf2);
501  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_PUNCH][i].buf3);
502  found++;
503  break;
504  }
505  } else if (USING_SKILL(hitter, SK_WRAITH_FEED)) {
506  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_WRAITH_FEED][i].level != -1; i++)
507  if (dam < attack_mess[ATM_WRAITH_FEED][i].level) {
508  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_WRAITH_FEED][i].buf1, op->name, attack_mess[ATM_WRAITH_FEED][i].buf2);
509  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_WRAITH_FEED][i].buf3);
510  found++;
511  break;
512  }
513  }
514  }
515  if (found) {
516  /* done */
517  } else if (IS_ARROW(hitter) && (type == AT_PHYSICAL || type == AT_MAGIC)) {
518  snprintf(buf1, sizeof(buf1), "hit"); /* just in case */
519  for (i = 0; i < MAXATTACKMESS; i++)
520  if (dam < attack_mess[ATM_ARROW][i].level
521  || attack_mess[ATM_ARROW][i+1].level == -1) {
522  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_ARROW][i].buf3);
523  found++;
524  break;
525  }
526  } else if (type&AT_DRAIN && IS_LIVE(op)) {
527  /* drain is first, because some items have multiple attypes */
528  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_DRAIN][i].level != -1; i++)
529  if (dam < attack_mess[ATM_DRAIN][i].level
530  || attack_mess[ATM_DRAIN][i+1].level == -1) {
531  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_DRAIN][i].buf1, op->name, attack_mess[ATM_DRAIN][i].buf2);
532  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_DRAIN][i].buf3);
533  found++;
534  break;
535  }
536  } else if (type&AT_ELECTRICITY && IS_LIVE(op)) {
537  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_ELEC][i].level != -1; i++)
538  if (dam < attack_mess[ATM_ELEC][i].level
539  || attack_mess[ATM_ELEC][i+1].level == -1) {
540  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_ELEC][i].buf1, op->name, attack_mess[ATM_ELEC][i].buf2);
541  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_ELEC][i].buf3);
542  found++;
543  break;
544  }
545  } else if (type&AT_COLD && IS_LIVE(op)) {
546  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_COLD][i].level != -1; i++)
547  if (dam < attack_mess[ATM_COLD][i].level
548  || attack_mess[ATM_COLD][i+1].level == -1) {
549  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_COLD][i].buf1, op->name, attack_mess[ATM_COLD][i].buf2);
550  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_COLD][i].buf3);
551  found++;
552  break;
553  }
554  } else if (type&AT_FIRE) {
555  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_FIRE][i].level != -1; i++)
556  if (dam < attack_mess[ATM_FIRE][i].level
557  || attack_mess[ATM_FIRE][i+1].level == -1) {
558  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_FIRE][i].buf1, op->name, attack_mess[ATM_FIRE][i].buf2);
559  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_FIRE][i].buf3);
560  found++;
561  break;
562  }
563  } else if (hitter->current_weapon != NULL) {
564  int mtype;
565 
566  switch (hitter->current_weapon->weapontype) {
567  case WEAP_HIT: mtype = ATM_BASIC; break;
568  case WEAP_SLASH: mtype = ATM_SLASH; break;
569  case WEAP_PIERCE: mtype = ATM_PIERCE; break;
570  case WEAP_CLEAVE: mtype = ATM_CLEAVE; break;
571  case WEAP_SLICE: mtype = ATM_SLICE; break;
572  case WEAP_STAB: mtype = ATM_STAB; break;
573  case WEAP_WHIP: mtype = ATM_WHIP; break;
574  case WEAP_CRUSH: mtype = ATM_CRUSH; break;
575  case WEAP_BLUD: mtype = ATM_BLUD; break;
576  default: mtype = ATM_BASIC; break;
577  }
578  for (i = 0; i < MAXATTACKMESS && attack_mess[mtype][i].level != -1; i++)
579  if (dam < attack_mess[mtype][i].level
580  || attack_mess[mtype][i+1].level == -1) {
581  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[mtype][i].buf1, op->name, attack_mess[mtype][i].buf2);
582  snprintf(buf2, sizeof(buf2), "%s", attack_mess[mtype][i].buf3);
583  found++;
584  break;
585  }
586  } else {
587  for (i = 0; i < MAXATTACKMESS && attack_mess[ATM_BASIC][i].level != -1; i++)
588  if (dam < attack_mess[ATM_BASIC][i].level
589  || attack_mess[ATM_BASIC][i+1].level == -1) {
590  snprintf(buf1, sizeof(buf1), "%s %s%s", attack_mess[ATM_BASIC][i].buf1, op->name, attack_mess[ATM_BASIC][i].buf2);
591  snprintf(buf2, sizeof(buf2), "%s", attack_mess[ATM_BASIC][i].buf3);
592  found++;
593  break;
594  }
595  }
596 
597  if (!found) {
598  snprintf(buf1, sizeof(buf1), "hit");
599  snprintf(buf2, sizeof(buf2), "hits");
600  }
601 
602  if (dam != 0) {
603  if (hitter->chosen_skill)
604  play_sound_map(SOUND_TYPE_HIT, hitter, 0, hitter->chosen_skill->name);
605  else if (dam < 10)
606  play_sound_map(SOUND_TYPE_HIT, hitter, 0, "low");
607  else if (dam < 20)
608  play_sound_map(SOUND_TYPE_HIT, hitter, 0, "medium");
609  else
610  play_sound_map(SOUND_TYPE_HIT, hitter, 0, "high");
611  }
612 
613  /* bail out if a monster is casting spells */
614  owner = object_get_owner(hitter);
615  if (hitter->type != PLAYER && (owner == NULL || owner->type != PLAYER))
616  return;
617 
618  /* scale down magic considerably. */
619  if (type&AT_MAGIC && rndm(0, 5))
620  return;
621 
622  /* Did a player hurt another player? Inform both! */
623  /* only show half the player->player combat messages */
624  if (op->type == PLAYER
625  && rndm(0, 1)
626  && ((owner != NULL ? owner : hitter)->type) == PLAYER) {
627  if (owner != NULL)
628  snprintf(buf, sizeof(buf), "%s's %s %s you.", owner->name, hitter->name, buf2);
629  else {
630  snprintf(buf, sizeof(buf), "%s%s you.", hitter->name, buf2);
631  }
632  draw_ext_info(NDI_BLACK, 0, op, MSG_TYPE_VICTIM, MSG_TYPE_VICTIM_WAS_HIT, buf);
633  } /* end of player hitting player */
634 
635  /* scale down these messages too */
636  /*if(hitter->type == PLAYER && rndm(0, 2) == 0) {*/
637  if (hitter->type == PLAYER) {
638  snprintf(buf, sizeof(buf), "You %s.", buf1);
639  draw_ext_info(NDI_BLACK, 0, hitter, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_DID_HIT,
640  buf);
641  } else if (owner != NULL && owner->type == PLAYER) {
642  /* look for stacked spells and start reducing the message chances */
643  if (hitter->type == SPELL_EFFECT
644  && (hitter->subtype == SP_EXPLOSION || hitter->subtype == SP_BULLET || hitter->subtype == SP_CONE)) {
645  i = 4;
646  map = hitter->map;
647  if (out_of_map(map, hitter->x, hitter->y))
648  return;
649  FOR_MAP_PREPARE(map, hitter->x, hitter->y, next)
650  if (next->type == SPELL_EFFECT
651  && (next->subtype == SP_EXPLOSION || next->subtype == SP_BULLET || next->subtype == SP_CONE)) {
652  i *= 3;
653  if (i > 10000)
654  /* no need to test more, and avoid overflows */
655  break;
656  }
657  FOR_MAP_FINISH();
658  if (i < 0)
659  return;
660  if (rndm(0, i) != 0)
661  return;
662  } else if (rndm(0, 5) != 0)
663  return;
664  play_sound_map(SOUND_TYPE_HIT, owner, 0, "hit");
665  draw_ext_info_format(NDI_BLACK, 0, owner, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_PET_HIT,
666  "Your %s%s %s.",
667  hitter->name, buf2, op->name);
668  }
669 }
670 
682 static int get_attack_mode(object **target, object **hitter,
683  int *simple_attack) {
684  if (QUERY_FLAG(*target, FLAG_FREED) || QUERY_FLAG(*hitter, FLAG_FREED)) {
685  LOG(llevError, "BUG: get_attack_mode(): freed object\n");
686  return 1;
687  }
688  *target = HEAD(*target);
689  *hitter = HEAD(*hitter);
690  if ((*hitter)->env != NULL || (*target)->env != NULL) {
691  *simple_attack = 1;
692  return 0;
693  }
694  if (QUERY_FLAG(*target, FLAG_REMOVED)
695  || QUERY_FLAG(*hitter, FLAG_REMOVED)
696  || (*hitter)->map == NULL
697  || !on_same_map((*hitter), (*target))) {
698  LOG(llevError, "BUG: hitter (arch %s, name %s) with no relation to target\n", (*hitter)->arch->name, (*hitter)->name);
699  return 1;
700  }
701  *simple_attack = 0;
702  return 0;
703 }
704 
718 static int abort_attack(object *target, object *hitter, int simple_attack) {
719  int new_mode;
720 
721  if (hitter->env == target || target->env == hitter)
722  new_mode = 1;
723  else if (QUERY_FLAG(hitter, FLAG_REMOVED)
724  || QUERY_FLAG(target, FLAG_REMOVED)
725  || hitter->map == NULL || !on_same_map(hitter, target))
726  return 1;
727  else
728  new_mode = 0;
729  return new_mode != simple_attack;
730 }
731 
732 static void thrown_item_effect(object *, object *);
733 
749 static int attack_ob_simple(object *op, object *hitter, int base_dam, int base_wc) {
750  int simple_attack, roll, dam;
751  uint32_t type;
752  tag_t op_tag, hitter_tag;
753 
754  if (get_attack_mode(&op, &hitter, &simple_attack))
755  return 1;
756 
757  /* Lauwenmark: This is used to handle script_weapons with weapons.
758  * Only used for players.
759  */
760  if (hitter->type == PLAYER) {
761  if (hitter->current_weapon != NULL) {
762  /* Lauwenmark: Handle for plugin attack event */
763  if (execute_event(hitter->current_weapon, EVENT_ATTACKS,
764  hitter, op, NULL, SCRIPT_FIX_ALL) != 0)
765  return 0;
766  if (hitter->current_weapon->anim_suffix)
767  apply_anim_suffix(hitter, hitter->current_weapon->anim_suffix);
768  } else if (hitter->chosen_skill && hitter->chosen_skill->anim_suffix)
769  /* if no weapon, then skill (karate, wraith feed) attack */
770  apply_anim_suffix(hitter, hitter->chosen_skill->anim_suffix);
771  }
772  op_tag = op->count;
773  hitter_tag = hitter->count;
774  /*
775  * A little check to make it more difficult to dance forward and back
776  * to avoid ever being hit by monsters.
777  */
778  if (!simple_attack && QUERY_FLAG(op, FLAG_MONSTER)
779  && op->speed_left > -(FABS(op->speed))*0.3) {
780  /* Decrease speed BEFORE calling process_object. Otherwise, an
781  * infinite loop occurs, with process_object calling monster_move(),
782  * which then gets here again. By decreasing the speed before
783  * we call process_object, the 'if' statement above will fail.
784  */
785  op->speed_left--;
786  process_object(op);
787  if (object_was_destroyed(op, op_tag)
788  || object_was_destroyed(hitter, hitter_tag)
789  || abort_attack(op, hitter, simple_attack))
790  return 1;
791  }
792 
793  roll = random_roll(1, 20, hitter, PREFER_HIGH);
794 
795  /* Adjust roll for various situations. */
796  if (!simple_attack)
797  roll += adj_attackroll(hitter, op);
798 
799  /* See if we hit the creature */
800  if (roll >= 20 || op->stats.ac >= base_wc-roll) {
801  if (settings.casting_time == TRUE) {
802  if (hitter->type == PLAYER && hitter->casting_time > -1) {
803  hitter->casting_time = -1;
804  draw_ext_info(NDI_UNIQUE, 0, hitter, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_FUMBLE,
805  "You attacked and lost your spell!");
806  }
807  if (op->casting_time > -1 && base_dam > 0) {
808  op->casting_time = -1;
809  if (op->type == PLAYER) {
810  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_FUMBLE,
811  "You were hit and lost your spell!");
812  draw_ext_info_format(NDI_ALL|NDI_UNIQUE, 5, NULL,
813  MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_FUMBLE,
814  "%s was hit by %s and lost a spell.",
815  op->name, hitter->name);
816  }
817  }
818  }
819  if (!simple_attack) {
820  /* If you hit something, the victim should *always *wake up.
821  * Before, invisible hitters could avoid doing this.
822  * -b.t. */
823  if (QUERY_FLAG(op, FLAG_SLEEP))
824  CLEAR_FLAG(op, FLAG_SLEEP);
825 
826  /* If the victim can't see the attacker, it may alert others
827  * for help. */
828  if (op->type != PLAYER && !monster_can_see_enemy(op, hitter)
829  && !object_get_owner(op) && rndm(0, op->stats.Int))
830  monster_npc_call_help(op);
831 
832  /* if you were hidden and hit by a creature, you are discovered*/
833  if (op->hide && QUERY_FLAG(hitter, FLAG_ALIVE)) {
834  make_visible(op);
835  if (op->type == PLAYER)
836  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_VICTIM, MSG_TYPE_VICTIM_WAS_HIT,
837  "You were hit by a wild attack. You are no longer hidden!");
838  }
839 
840  /* thrown items (hitter) will have various effects
841  * when they hit the victim. For things like thrown daggers,
842  * this sets 'hitter' to the actual dagger, and not the
843  * wrapper object.
844  */
845  thrown_item_effect(hitter, op);
846  if (object_was_destroyed(hitter, hitter_tag)
847  || object_was_destroyed(op, op_tag)
848  || abort_attack(op, hitter, simple_attack)) {
849  return 0;
850  }
851  }
852 
853  /* Need to do at least 1 damage, otherwise there is no point
854  * to go further and it will cause FPE's below.
855  */
856  if (base_dam <= 0)
857  base_dam = 1;
858 
859  type = hitter->attacktype;
860  if (!type)
861  type = AT_PHYSICAL;
862  /* Handle monsters that hit back */
863  if (!simple_attack && QUERY_FLAG(op, FLAG_HITBACK)
864  && QUERY_FLAG(hitter, FLAG_ALIVE)) {
865  if (op->attacktype&AT_ACID && hitter->type == PLAYER)
866  draw_ext_info(NDI_UNIQUE, 0, hitter, MSG_TYPE_VICTIM, MSG_TYPE_VICTIM_WAS_HIT,
867  "You are splashed by acid!\n");
868  hit_player(hitter, random_roll(0, (op->stats.dam), hitter, PREFER_LOW), op, op->attacktype, 1);
869  if (object_was_destroyed(op, op_tag)
870  || object_was_destroyed(hitter, hitter_tag)
871  || abort_attack(op, hitter, simple_attack)) {
872  return 0;
873  }
874  }
875 
876  /* In the new attack code, it should handle multiple attack
877  * types in its area, so remove it from here.
878  */
879  dam = hit_player(op, random_roll(1, base_dam, hitter, PREFER_HIGH), hitter, type, 1);
880  if (object_was_destroyed(op, op_tag)
881  || object_was_destroyed(hitter, hitter_tag)
882  || abort_attack(op, hitter, simple_attack)) {
883  return 0;
884  }
885  } else {/* end of if hitter hit op */
886  dam = 0; /* if we missed, dam=0 */
887  }
888 
889  /*attack_message(dam, type, op, hitter);*/
890 
891  return dam;
892 }
893 
903 int attack_ob(object *op, object *hitter) {
904  hitter = HEAD(hitter);
905  return attack_ob_simple(op, hitter, hitter->stats.dam, hitter->stats.wc);
906 }
907 
918 static int stick_arrow(object *op, object *tmp) {
919  /* If the missile hit a player, we insert it in their inventory.
920  * However, if the missile is heavy, we don't do so (assume it falls
921  * to the ground after a hit). What a good value for this is up to
922  * debate - 5000 is 5 kg, so arrows, knives, and other light weapons
923  * stick around.
924  */
925  if (op->weight <= 5000 && tmp->stats.hp >= 0) {
926  object_remove(op);
927  op = object_insert_in_ob(op, HEAD(tmp));
928  return 1;
929  } else
930  return 0;
931 }
932 
945 object *hit_with_arrow(object *op, object *victim) {
946  object *container, *hitter;
947  int hit_something = 0;
948  tag_t victim_tag, hitter_tag, container_tag;
949  int16_t victim_x, victim_y;
950  mapstruct *victim_map;
951  const char *old_skill = NULL;
952 
953  /* Disassemble missile */
954  hitter = op->inv;
955  FOR_OB_AND_BELOW_PREPARE(hitter)
956  if (hitter->type != EVENT_CONNECTOR) {
957  break;
958  }
959  FOR_OB_AND_BELOW_FINISH();
960  if (!hitter) {
961  container = NULL;
962  hitter = op;
963  if (free_no_drop(hitter))
964  return NULL;
965  } else {
966  container = op;
967  object_remove(hitter);
968  if (free_no_drop(hitter))
969  return NULL;
970 
971  object_insert_in_map_at(hitter, container->map, hitter, INS_NO_MERGE|INS_NO_WALK_ON, container->x, container->y);
972  /* Note that we now have an empty THROWN_OBJ on the map. Code that
973  * might be called until this THROWN_OBJ is either reassembled or
974  * removed at the end of this function must be able to deal with empty
975  * THROWN_OBJs. */
976  container_tag = container->count;
977  }
978 
979  /* Try to hit victim */
980  victim_x = victim->x;
981  victim_y = victim->y;
982  victim_map = victim->map;
983  victim_tag = victim->count;
984  hitter_tag = hitter->count;
985  /* Lauwenmark: Handling plugin attack event for thrown items */
986  /* FIXME provide also to script the skill? hitter is the throwed
987  items, but there is no information about the fact it was
988  thrown
989  */
990  if (execute_event(op, EVENT_ATTACKS, hitter, victim, NULL, SCRIPT_FIX_ALL) == 0) {
991  /*
992  * temporary set the hitter's skill to the one associated with the
993  * throw wrapper. This is needed to that thrower gets it's xp at the
994  * correct level. This might proves an awfull hack :/ We should really
995  * provide attack_ob_simple with the skill to use...
996  */
997  if (container != NULL) {
998  old_skill = hitter->skill;
999  hitter->skill = add_refcount(container->skill);
1000  }
1001  hit_something = attack_ob_simple(victim, hitter, op->stats.dam, op->stats.wc);
1002  }
1003  /* Arrow attacks door, rune of summoning is triggered, demon is put on
1004  * arrow, move_apply() calls this function, arrow sticks in demon,
1005  * attack_ob_simple() returns, and we've got an arrow that still exists
1006  * but is no longer on the map. Ugh. (Beware: Such things can happen at
1007  * other places as well!)
1008  */
1009  if (object_was_destroyed(hitter, hitter_tag) || hitter->env != NULL) {
1010  if (container) {
1011  object_remove(container);
1012  object_free_drop_inventory(container);
1013  }
1014  return NULL;
1015  }
1016  if (container != NULL) {
1017  free_string(hitter->skill);
1018  hitter->skill = old_skill;
1019  }
1020  /* Missile hit victim */
1021  /* if the speed is > 10, then this is a fast moving arrow, we go straight
1022  * through the target
1023  */
1024  if (hit_something && op->speed <= 10.0) {
1025  /* Stop arrow */
1026  if (container == NULL) {
1027  hitter = fix_stopped_arrow(hitter);
1028  if (hitter == NULL)
1029  return NULL;
1030  } else {
1031  if(!object_was_destroyed(container, container_tag)) {
1032  object_remove(container);
1033  object_free_drop_inventory(container);
1034  }
1035  }
1036 
1037  /* Try to stick arrow into victim */
1038  if (!object_was_destroyed(victim, victim_tag)
1039  && stick_arrow(hitter, victim)) {
1040  object_set_owner(hitter, NULL);
1041  return NULL;
1042  }
1043 
1044  /* Else try to put arrow on victim's map square
1045  * remove check for P_WALL here. If the arrow got to this
1046  * space, that is good enough - with the new movement code,
1047  * there is now the potential for lots of spaces where something
1048  * can fly over but not otherwise move over. What is the correct
1049  * way to handle those otherwise?
1050  */
1051  if (victim_x != hitter->x || victim_y != hitter->y) {
1052  object_remove(hitter);
1053  object_set_owner(hitter, NULL);
1054  object_insert_in_map_at(hitter, victim_map, hitter, 0, victim_x, victim_y);
1055  } else {
1056  /* Else leave arrow where it is */
1057  object_merge(hitter, NULL);
1058  object_set_owner(hitter, NULL);
1059  }
1060  return NULL;
1061  }
1062 
1063  if (hit_something && op->speed >= 10.0)
1064  op->speed -= 1.0;
1065 
1066  /* Missile missed victim - reassemble missile */
1067  if (container) {
1068  object_remove(hitter);
1069  object_insert_in_ob(hitter, container);
1070  }
1071  return op;
1072 }
1080 static void tear_down_wall(object *op) {
1081  int perc = 0;
1082 
1083  if (!op->stats.maxhp) {
1084  LOG(llevError, "TEAR_DOWN wall %s had no maxhp.\n", op->name);
1085  perc = 1;
1086  } else if (!GET_ANIM_ID(op)) {
1087  /* Object has been called - no animations, so remove it */
1088  if (op->stats.hp < 0) {
1089  object_remove(op); /* Should update LOS */
1090  object_free_drop_inventory(op);
1091  /* Don't know why this is here - object_remove() should do it for us */
1092  /*update_position(m, x, y);*/
1093  }
1094  return; /* no animations, so nothing more to do */
1095  }
1096  assert(op->stats.maxhp > 0);
1097  perc = NUM_ANIMATIONS(op)-((int)NUM_ANIMATIONS(op)*op->stats.hp)/op->stats.maxhp;
1098 
1099  if (perc >= (int)NUM_ANIMATIONS(op))
1100  perc = NUM_ANIMATIONS(op)-1;
1101  else if (perc < 1)
1102  perc = 1;
1103  SET_ANIMATION(op, perc);
1104  object_update(op, UP_OBJ_FACE);
1105  if (perc == NUM_ANIMATIONS(op)-1) { /* Reached the last animation */
1106  if (op->face == blank_face) {
1107  /* If the last face is blank, remove the ob */
1108  object_remove(op); /* Should update LOS */
1109  object_free_drop_inventory(op);
1110 
1111  /* object_remove() should call update_position for us */
1112  /*update_position(m, x, y);*/
1113  } else { /* The last face was not blank, leave an image */
1114  CLEAR_FLAG(op, FLAG_BLOCKSVIEW);
1115  update_all_los(op->map, op->x, op->y);
1116  op->move_block = 0;
1117  CLEAR_FLAG(op, FLAG_ALIVE);
1118  }
1119  }
1120 }
1121 
1129 static void scare_creature(object *target, object *hitter) {
1130  object *owner = object_get_owner(hitter);
1131 
1132  if (!owner)
1133  owner = hitter;
1134 
1135  SET_FLAG(target, FLAG_SCARED);
1136  if (!target->enemy)
1137  object_set_enemy(target, owner);
1138 }
1139 
1156 static int hit_with_one_attacktype(object *op, object *hitter, int dam, uint32_t attacknum) {
1157  int doesnt_slay = 1;
1158  char name_hitter[MAX_BUF], name_op[MAX_BUF];
1159 
1160  /* Catch anyone that may be trying to send us a bitmask instead of the number */
1161  if (attacknum >= NROFATTACKS) {
1162  LOG(llevError, "hit_with_one_attacktype: Invalid attacknumber passed: %u\n", attacknum);
1163  return 0;
1164  }
1165 
1166  if (dam < 0) {
1167  LOG(llevError, "hit_with_one_attacktype called with negative damage: %d\n", dam);
1168  return 0;
1169  }
1170 
1171  if (hitter->current_weapon && hitter->current_weapon->discrete_damage != NULL)
1172  dam = hitter->current_weapon->discrete_damage[attacknum];
1173  else if (hitter->discrete_damage != NULL)
1174  dam = hitter->discrete_damage[attacknum];
1175 
1176  /* AT_INTERNAL is supposed to do exactly dam. Put a case here so
1177  * people can't mess with that or it otherwise get confused. */
1178  if (attacknum == ATNR_INTERNAL)
1179  return dam;
1180 
1181  if (hitter->slaying) {
1182  // Look for the race as one of many that can be listed.
1183  if ((op->race != NULL && strstr(op->race, hitter->slaying))
1184  /*
1185  * Since we can do multiple races, we should be able to avoid the arch check.
1186  * This gives a more flexible race system, so skeletal mages can be a type of skeleton and such
1187  || (op->arch && op->arch->name != NULL && strstr(op->arch->name, hitter->slaying))
1188  */) {
1189  doesnt_slay = 0;
1190  dam *= 3;
1191  }
1192  }
1193 
1194  /* Adjust the damage for resistance. Note that neg. values increase damage. */
1195  /*
1196  * Skip lifestealing here, because it undergoes a more specific resistance scaling
1197  * in its own section that involves the better of drain/life stealing resistance
1198  *
1199  * Daniel Hawkins 2018-05-31
1200  */
1201  if (attacknum != ATNR_LIFE_STEALING && op->resist[attacknum]) {
1202  /* basically: dam = dam*(100-op->resist[attacknum])/100;
1203  * in case 0>dam>1, we try to "simulate" a float value-effect */
1204  dam *= (100-op->resist[attacknum]);
1205  if (dam >= 100)
1206  dam /= 100;
1207  else
1208  dam = (dam > (random_roll(0, 99, op, PREFER_LOW))) ? 1 : 0;
1209  }
1210 
1211  /* Special hack. By default, if immune to something, you
1212  * shouldn't need to worry. However, acid is an exception, since
1213  * it can still damage your items. Only include attacktypes if
1214  * special processing is needed */
1215 
1216  if (op->resist[attacknum] >= 100
1217  && doesnt_slay
1218  && attacknum != ATNR_ACID)
1219  return 0;
1220 
1221  /* Keep this in order - makes things easier to find */
1222 
1223  switch (attacknum) {
1224  case ATNR_PHYSICAL:
1225  /* here also check for diseases */
1226  check_physically_infect(op, hitter);
1227  break;
1228 
1229  /* Don't need to do anything for:
1230  magic,
1231  fire,
1232  electricity,
1233  cold */
1234 
1235  case ATNR_CONFUSION:
1236  case ATNR_POISON:
1237  case ATNR_SLOW:
1238  case ATNR_PARALYZE:
1239  case ATNR_FEAR:
1240  case ATNR_CANCELLATION:
1241  case ATNR_DEPLETE:
1242  case ATNR_BLIND: {
1243  /* chance for inflicting a special attack depends on the
1244  * difference between attacker's and defender's level
1245  */
1246  int level_diff = MIN(110, MAX(0, op->level-hitter->level));
1247 
1248  /* First, only creatures/players with speed can be affected.
1249  * Second, just getting hit doesn't mean it always affects
1250  * you. Third, you still get a saving through against the
1251  * effect.
1252  */
1253  if (op->speed
1254  && (QUERY_FLAG(op, FLAG_MONSTER) || op->type == PLAYER)
1255  && !(rndm(0, (attacknum == ATNR_SLOW ? 6 : 3)-1))
1256  && !did_make_save(op, level_diff, op->resist[attacknum]/10)) {
1257  /* Player has been hit by something */
1258  if (attacknum == ATNR_CONFUSION)
1259  confuse_living(op, hitter, dam);
1260  else if (attacknum == ATNR_POISON)
1261  poison_living(op, hitter, dam);
1262  else if (attacknum == ATNR_SLOW)
1263  slow_living(op, hitter, dam);
1264  else if (attacknum == ATNR_PARALYZE)
1265  paralyze_living(op, dam);
1266  else if (attacknum == ATNR_FEAR)
1267  scare_creature(op, hitter);
1268  else if (attacknum == ATNR_CANCELLATION)
1269  cancellation(op);
1270  else if (attacknum == ATNR_DEPLETE)
1271  drain_stat(op);
1272  else if (attacknum == ATNR_BLIND
1273  && !QUERY_FLAG(op, FLAG_UNDEAD)
1274  && !QUERY_FLAG(op, FLAG_GENERATOR))
1275  blind_living(op, hitter, dam);
1276  }
1277  dam = 0; /* These are all effects and don't do real damage */
1278  }
1279  break;
1280 
1281  case ATNR_ACID: {
1282  int flag = 0;
1283 
1284  /* Items only get corroded if you're not on a battleground and
1285  * if your acid resistance is below 50%. */
1286  if (!op_on_battleground(op, NULL, NULL, NULL)
1287  && (op->resist[ATNR_ACID] < 50)) {
1288  FOR_INV_PREPARE(op, tmp) {
1289  if (tmp->invisible)
1290  continue;
1291  if (!QUERY_FLAG(tmp, FLAG_APPLIED)
1292  || (tmp->resist[ATNR_ACID] >= 10))
1293  /* >= 10% acid res. on itmes will protect these */
1294  continue;
1295  if (!(tmp->material&M_IRON))
1296  continue;
1297  if (tmp->magic < -4) /* Let's stop at -5 */
1298  continue;
1299  if (tmp->type == RING
1300  /* removed boots and gloves from exclusion list in PR */
1301  || tmp->type == GIRDLE
1302  || tmp->type == AMULET
1303  || tmp->type == WAND
1304  || tmp->type == ROD)
1305  continue; /* To avoid some strange effects */
1306 
1307  /* High damage acid has better chance of corroding objects */
1308  if (rndm(0, dam+4) > random_roll(0, 39, op, PREFER_HIGH)+2*tmp->magic) {
1309  if (op->type == PLAYER) {
1310  /* Make this more visible */
1311  query_name(hitter, name_hitter, MAX_BUF);
1312  query_name(tmp, name_op, MAX_BUF);
1313  draw_ext_info_format(NDI_UNIQUE|NDI_RED, 0, op,
1314  MSG_TYPE_VICTIM, MSG_TYPE_VICTIM_WAS_HIT,
1315  "The %s's acid corrodes your %s!",
1316  name_hitter, name_op);
1317  }
1318  flag = 1;
1319  tmp->magic--;
1320  if (op->type == PLAYER)
1321  esrv_update_item(UPD_NAME, op, tmp);
1322  }
1323  } FOR_INV_FINISH();
1324  if (flag)
1325  fix_object(op); /* Something was corroded */
1326  }
1327  }
1328  break;
1329 
1330  case ATNR_DRAIN: {
1331  /* rate is the proportion of exp drained. High rate means
1332  * not much is drained, low rate means a lot is drained.
1333  */
1334  int rate;
1335 
1336  if (op->resist[ATNR_DRAIN] >= 0)
1337  rate = 50+op->resist[ATNR_DRAIN]/2;
1338  else
1339  rate = 5000/(100-op->resist[ATNR_DRAIN]);
1340 
1341  /* full protection has no effect. Nothing else in this
1342  * function needs to get done, so just return. */
1343  if (!rate)
1344  return 0;
1345 
1346  if (op->stats.exp <= rate) {
1347  if (op->type == GOLEM)
1348  dam = 999; /* Its force is "sucked" away. 8) */
1349  else
1350  /* If we can't drain, lets try to do physical damage */
1351  dam = hit_with_one_attacktype(op, hitter, dam, ATNR_PHYSICAL);
1352  } else {
1353  /* Randomly give the hitter some hp */
1354  if (hitter->stats.hp < hitter->stats.maxhp
1355  && (op->level > hitter->level)
1356  && random_roll(0, (op->level-hitter->level+2), hitter, PREFER_HIGH) > 3)
1357  hitter->stats.hp++;
1358 
1359  /* Can't do drains on battleground spaces.
1360  * Move the wiz check up here - before, the hitter wouldn't gain exp
1361  * exp, but the wiz would still lose exp! If drainee is a wiz,
1362  * nothing happens.
1363  * Try to credit the owner. We try to display player -> player drain
1364  * attacks, hence all the != PLAYER checks.
1365  */
1366  if (!op_on_battleground(hitter, NULL, NULL, NULL) && !QUERY_FLAG(op, FLAG_WAS_WIZ)) {
1367  object *owner = object_get_owner(hitter);
1368  int64_t orig_exp = op->stats.exp;
1369 
1370  change_exp(op, -op->stats.exp/rate, NULL, 0);
1371 
1372  if (owner && owner != hitter) {
1373  if (op->type != PLAYER || owner->type != PLAYER)
1374  change_exp(owner, MIN(op->stats.exp/(rate*2), orig_exp - op->stats.exp),
1375  hitter->chosen_skill ? hitter->chosen_skill->skill : NULL, SK_EXP_TOTAL);
1376  } else if (op->type != PLAYER || hitter->type != PLAYER) {
1377  change_exp(hitter, MIN(op->stats.exp/(rate*2), orig_exp - op->stats.exp),
1378  hitter->chosen_skill ? hitter->chosen_skill->skill : NULL, 0);
1379  }
1380  }
1381  dam = 1; /* Drain is an effect. Still return 1 - otherwise, if you have pure
1382  * drain attack, you won't know that you are actually sucking out EXP,
1383  * as the messages will say you missed
1384  */
1385  }
1386  }
1387  break;
1388 
1389  case ATNR_TURN_UNDEAD: {
1390  if (QUERY_FLAG(op, FLAG_UNDEAD)) {
1391  object *owner = object_get_owner(hitter) == NULL ? hitter : object_get_owner(hitter);
1392  const object *god = find_god(determine_god(owner));
1393  int div = 1;
1394 
1395  /* if undead are not an enemy of your god, you turn them
1396  * at half strength */
1397  if (!god
1398  || !god->slaying
1399  || strstr(god->slaying, undead_name) == NULL)
1400  div = 2;
1401 
1402  /* The previous code was highly suspect - resist turn undead/100 would
1403  * at best give a bonus of 1 - increase that to resist turn undead/20 -
1404  * this gives a bit higher bonus. Also the bonus was added to the wrong
1405  * side of the equation, actually making it easier to turn creatures
1406  * if they had that resistance.
1407  */
1408  if ((op->level*div + (op->resist[ATNR_TURN_UNDEAD] / 20)) < (get_turn_bonus(owner->stats.Wis)+owner->level))
1409  scare_creature(op, owner);
1410  } else
1411  dam = 0; /* don't damage non undead - should we damage undead? */
1412  }
1413  break;
1414 
1415  case ATNR_DEATH:
1416  deathstrike_living(op, hitter, &dam);
1417  break;
1418 
1419  case ATNR_CHAOS:
1420  query_name(op, name_op, MAX_BUF);
1421  query_name(hitter, name_hitter, MAX_BUF);
1422  LOG(llevError, "%s was hit by %s with non-specific chaos.\n", name_op, name_hitter);
1423  dam = 0;
1424  break;
1425 
1426  case ATNR_COUNTERSPELL:
1427  dam = 0;
1428  /* While counterspell is handled separately and filtered out when it
1429  * moves, players can still step on a square that has an active
1430  * counterspell. When this happens, do no damage because counterspell
1431  * has no effect on anything but spells. */
1432  break;
1433 
1434  case ATNR_HOLYWORD: {
1435  /* This has already been handled by hit_player,
1436  * no need to check twice -- DAMN */
1437 
1438  object *owner = object_get_owner(hitter) == NULL ? hitter : object_get_owner(hitter);
1439 
1440  /* As with turn undead above, give a bonus on the saving throw */
1441  if (op->level+(op->resist[ATNR_HOLYWORD]/100) < owner->level+get_turn_bonus(owner->stats.Wis))
1442  scare_creature(op, owner);
1443  }
1444  break;
1445 
1446  case ATNR_LIFE_STEALING: {
1447  int new_hp;
1448  /* this is replacement to drain for players, instead of taking
1449  * exp it takes hp. It is geared for players, probably not
1450  * much use giving it to monsters
1451  *
1452  * life stealing doesn't do a lot of damage, but it gives the
1453  * damage it does do to the player. Given that,
1454  * it only does 1/30'th normal damage (hence the divide by
1455  * 3000). Wraith get 1/2 of the damage, and therefore divide
1456  * by 200. This number may need tweaking for game balance.
1457  */
1458 
1459  int dam_modifier = is_wraith_pl(hitter) ? 200 : 3000;
1460 
1461  /* You can't steal life from something undead or not alive. */
1462  if (op->type == GOLEM
1463  || (QUERY_FLAG(op, FLAG_UNDEAD))
1464  || !(QUERY_FLAG(op, FLAG_ALIVE))
1465  || (op->type == DOOR))
1466  return 0;
1467  /* If drain protection is higher than life stealing, use that */
1468  if (op->resist[ATNR_DRAIN] >= op->resist[ATNR_LIFE_STEALING])
1469  dam = (dam*(100-op->resist[ATNR_DRAIN]))/dam_modifier;
1470  else
1471  dam = (dam*(100-op->resist[ATNR_LIFE_STEALING]))/dam_modifier;
1472  /* You die at -1 hp, not zero. */
1473  if (dam > op->stats.hp+1)
1474  dam = op->stats.hp+1;
1475  new_hp = hitter->stats.hp+dam;
1476  if (new_hp > hitter->stats.maxhp)
1477  new_hp = hitter->stats.maxhp;
1478  if (new_hp > hitter->stats.hp)
1479  hitter->stats.hp = new_hp;
1480 
1481  /* Wraith also get food through life stealing */
1482  if (is_wraith_pl(hitter)) {
1483  if (hitter->stats.food+dam >= 999)
1484  hitter->stats.food = 999;
1485  else
1486  hitter->stats.food += dam;
1487  fix_object(hitter);
1488  }
1489  }
1490  }
1491  return dam;
1492 }
1493 
1494 /*
1495  * This function is defined in party.c, but conditionally, something "make proto"
1496  * doesn't handle. So define it locally.
1497  */
1498 #ifdef PARTY_KILL_LOG
1499 void party_add_kill(partylist *party, const char *killer, const char *dead, long exp);
1500 #endif
1501 
1529 static int kill_object(object *op, int dam, object *hitter) {
1530  char kill_message[MAX_BUF];
1531  const char *skill;
1532  int maxdam = 0;
1533  int battleg = 0; /* true if op standing on battleground */
1534  int pk = 0; /* true if op and what controls hitter are both players*/
1535  object *owner = NULL;
1536  const object *skop = NULL;
1537  sstring death_animation;
1538 
1539  if (op->stats.hp >= 0)
1540  return -1;
1541 
1542  /* Lauwenmark: Handle for plugin death event */
1543  if (execute_event(op, EVENT_DEATH, hitter, NULL, NULL, SCRIPT_FIX_ALL) != 0)
1544  return 0;
1545  /* Lauwenmark: Handle for the global kill event */
1546  execute_global_event(EVENT_GKILL, op, hitter);
1547 
1548  if (op->map) {
1549  death_animation = object_get_value(op, "death_animation");
1550  if (death_animation != NULL) {
1551  object *death = create_archetype(death_animation);
1552 
1553  if (death)
1554  object_insert_in_map_at(death, op->map, op, 0, op->x, op->y);
1555  }
1556  }
1557 
1558  /* maxdam needs to be the amount of damage it took to kill
1559  * this creature. The function(s) that call us have already
1560  * adjusted the creatures HP total, so that is negative.
1561  */
1562  maxdam = dam+op->stats.hp+1;
1563 
1564  if (QUERY_FLAG(op, FLAG_BLOCKSVIEW))
1565  update_all_los(op->map, op->x, op->y); /* makes sure los will be recalculated */
1566 
1567  if (op->type == DOOR) {
1568  op->speed = 0.1;
1569  object_update_speed(op);
1570  op->speed_left = -0.05;
1571  return maxdam;
1572  }
1573  if (QUERY_FLAG(op, FLAG_FRIENDLY) && op->type != PLAYER) {
1574  object *owner;
1575 
1576  remove_friendly_object(op);
1577  owner = object_get_owner(op);
1578  if (owner != NULL
1579  && owner->type == PLAYER) {
1580  if (owner->contr->ranges[range_golem] == op) {
1581  owner->contr->ranges[range_golem] = NULL;
1582  owner->contr->golem_count = 0;
1583  }
1584 
1585  /*play_sound_player_only(owner1->contr, SOUND_PET_IS_KILLED, 0, 0);*/
1586  /* Maybe we should include the owner that killed this, maybe not */
1587  draw_ext_info_format(NDI_UNIQUE, 0, owner, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_PET_DIED,
1588  "Your pet, the %s, is killed by %s.",
1589  op->name, hitter->name);
1590  }
1591  /*
1592  * there can be items both friendly and without any owner, for instance
1593  * in various maps, so this isn't an error.
1594  else
1595  LOG(llevError, "BUG: hit_player(): Encountered golem without owner.\n");
1596  */
1597 
1598  object_remove(op);
1599  object_free_drop_inventory(op);
1600  return maxdam;
1601  }
1602 
1603  /* Now lets start dealing with experience we get for killing something */
1604 
1605  owner = object_get_owner(hitter);
1606  if (owner == NULL)
1607  owner = hitter;
1608 
1609  /* is the victim (op) standing on battleground? */
1610  if (op_on_battleground(op, NULL, NULL, NULL))
1611  battleg = 1;
1612 
1613  /* is this player killing? -- Don't count it if you suicide, though. */
1614  if (op->type == PLAYER && owner->type == PLAYER && owner != op)
1615  pk = 1;
1616 
1617  /* Player killed something */
1618  if (owner->type == PLAYER) {
1619 
1620  /* Log players killing other players - makes it easier to detect
1621  * and filter out malicious player killers - that is why the
1622  * ip address is included.
1623  */
1624  if (op->type == PLAYER && !battleg) {
1625  time_t t = time(NULL);
1626  struct tm *tmv;
1627  char buf[256];
1628  char name[MAX_BUF];
1629 
1630  tmv = localtime(&t);
1631  strftime(buf, sizeof(buf), "%a %b %d %H:%M:%S %Y", tmv);
1632  query_name(op, name, MAX_BUF);
1633 
1634  LOG(llevInfo, "%s PLAYER_KILL_PLAYER: %s (%s) killed %s\n", buf, owner->name, owner->contr->socket.host, name);
1635  }
1636 
1637  /* try to filter some things out - basically, if you are
1638  * killing a level 1 creature and your level 20, you
1639  * probably don't want to see that.
1640  */
1641  if (owner->level < op->level*2 || op->stats.exp > 1000) {
1642  if (owner != hitter) {
1643  char killed[MAX_BUF], with[MAX_BUF];
1644 
1645  query_name(op, killed, MAX_BUF);
1646  query_name(hitter, with, MAX_BUF);
1647  draw_ext_info_format(NDI_BLACK, 0, owner, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_DID_KILL,
1648  "You killed %s with %s.",
1649  killed, with);
1650  } else {
1651  char killed[MAX_BUF];
1652 
1653  query_name(op, killed, MAX_BUF);
1654  draw_ext_info_format(NDI_BLACK, 0, owner, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_DID_KILL,
1655  "You killed %s.",
1656  killed);
1657  }
1658  /* Only play sounds for melee kills */
1659  if (hitter->type == PLAYER)
1660  play_sound_map(SOUND_TYPE_HIT, owner, 0, "kill");
1661  }
1662 
1663  /* If a player kills another player, not on
1664  * battleground, the "killer" looses 1 luck. Since this is
1665  * not reversible, it's actually quite a pain IMHO. -AV
1666  * Fix bug in that we were changing the luck of the hitter, not
1667  * player that the object belonged to - so if you killed another player
1668  * with spells, pets, whatever, there was no penalty.
1669  * Changed to make luck penalty configurable in settings.
1670  *
1671  * Simplified comparison since pk is no longer set to 1 if self-kill
1672  * -- SilverNexus 2017-06-17+
1673  */
1674  if (pk == 1 && !battleg)
1675  change_luck(owner, -settings.pk_luck_penalty);
1676 
1677  /* This code below deals with finding the appropriate skill
1678  * to credit exp to. This is a bit problematic - we should
1679  * probably never really have to look at current_weapon->skill
1680  */
1681  skill = NULL;
1682  if (hitter->skill && hitter->type != PLAYER)
1683  skill = hitter->skill;
1684  else if (owner->chosen_skill) {
1685  skill = owner->chosen_skill->skill;
1686  skop = owner->chosen_skill;
1687  } else if (QUERY_FLAG(owner, FLAG_READY_WEAPON))
1688  skill = owner->current_weapon->skill;
1689  else
1690  LOG(llevError, "kill_object - unable to find skill that killed monster\n");
1691 
1692  /* We have the skill we want to credit to - now find the object this goes
1693  * to. Make sure skop is an actual skill, and not a skill tool!
1694  */
1695  if ((!skop || skop->type != SKILL) && skill) {
1696  int i;
1697 
1698  for (i = 0; i < NUM_SKILLS; i++)
1699  if (owner->contr->last_skill_ob[i]
1700  && !strcmp(owner->contr->last_skill_ob[i]->skill, skill)) {
1701  skop = owner->contr->last_skill_ob[i];
1702  break;
1703  }
1704  }
1705  } /* Was it a player that hit somethign */
1706  else {
1707  skill = NULL;
1708  }
1709 
1710  /* Pet (or spell) killed something. */
1711  if (owner != hitter) {
1712  char name_op[MAX_BUF], name_hitter[MAX_BUF];
1713  const char *owner_prefix;
1714  const char *op_prefix;
1715 
1716  owner_prefix = !battleg && pk && owner->contr != NULL && !owner->contr->peaceful ? "hostile " : "";
1717  op_prefix = !battleg && pk && op->contr != NULL && !op->contr->peaceful ? "hostile " : "";
1718 
1719  query_name(op, name_op, MAX_BUF);
1720  query_name(hitter, name_hitter, MAX_BUF);
1721  snprintf(kill_message, sizeof(kill_message), "%s%s killed %s%s with %s%s.", owner_prefix, owner->name, op_prefix, name_op, name_hitter, battleg ? " (duel)" : (pk ? " (pk)" : ""));
1722  } else {
1723  const char *hitter_prefix;
1724  const char *op_prefix;
1725 
1726  hitter_prefix = !battleg && pk && hitter->contr != NULL && !hitter->contr->peaceful ? "hostile " : "";
1727  op_prefix = !battleg && pk && op->contr != NULL && !op->contr->peaceful ? "hostile " : "";
1728 
1729  snprintf(kill_message, sizeof(kill_message), "%s%s killed %s%s%s%s.", hitter_prefix, hitter->name, op_prefix, op->name,
1730  (QUERY_FLAG(hitter, FLAG_MONSTER)) || hitter->type == PLAYER ?
1731  " in hand to hand combat" : "", battleg ? " (duel)" : (pk ? " (pk)" : ""));
1732  }
1733  /* These may have been set in the player code section above */
1734  if (!skop)
1735  skop = hitter->chosen_skill;
1736  if (!skill && skop)
1737  skill = skop->skill;
1738 
1739  draw_ext_info(NDI_ALL, op->type == PLAYER ? 1 : 10, NULL, MSG_TYPE_ADMIN, MSG_TYPE_ADMIN_PLAYER,
1740  kill_message);
1741 
1742 
1743  /* If you didn't kill yourself, and your not the wizard */
1744  if (owner != op && !QUERY_FLAG(op, FLAG_WAS_WIZ)) {
1745  int64_t exp;
1746 
1747  exp = calc_skill_exp(owner, op, skop);
1748 
1749  /* Really don't give much experience for killing other players */
1750  if (op->type == PLAYER) {
1751  if (battleg) {
1752  draw_ext_info(NDI_UNIQUE, 0, owner, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_DID_KILL,
1753  "Your foe has fallen!\nVICTORY!!!");
1754  } else {
1755  exp = settings.pk_max_experience_percent*exp/100;
1756  if (settings.pk_max_experience >= 0)
1757  exp = MIN(settings.pk_max_experience, exp);
1758  /* Never exceed what victim can lose considering permanent exp. */
1759  exp = check_exp_loss(op, exp);
1760  }
1761  }
1762 
1763  /* Don't know why this is set this way - doesn't make
1764  * sense to just divide everything by two for no reason.
1765  */
1766 
1767  if (!settings.simple_exp)
1768  exp = exp/2;
1769 
1770  /* if op is standing on "battleground" (arena), no way to gain
1771  * exp by killing him
1772  */
1773  if (battleg)
1774  exp = 0;
1775 
1776 #ifdef PARTY_KILL_LOG
1777  if (owner->type == PLAYER && owner->contr->party != NULL) {
1778  char name[MAX_BUF];
1779  char op_name[MAX_BUF];
1780 
1781  query_name(owner, name, MAX_BUF);
1782  query_name(op, op_name, sizeof(op_name));
1783  party_add_kill(owner->contr->party, name, op_name, exp);
1784  }
1785 #endif
1786  share_exp(owner, exp, skill, SK_EXP_TOTAL);
1787  } /* end if person didn't kill himself */
1788 
1789  if (op->type != PLAYER) {
1790  object_remove(op);
1791  object_free_drop_inventory(op);
1792  /* Player has been killed! */
1793  } else {
1794  if (owner->type == PLAYER) {
1795  snprintf(op->contr->killer, BIG_NAME, "%s the %s", owner->name, owner->contr->title);
1796  } else {
1797  strncpy(op->contr->killer, hitter->name, BIG_NAME);
1798  op->contr->killer[BIG_NAME-1] = '\0';
1799  }
1800  /* Need to run kill_player (just in case, make sure is not wiz) */
1801  if (!QUERY_FLAG(op, FLAG_WIZ))
1802  kill_player(op, owner->type == PLAYER ? owner : hitter);
1803  }
1804  /* This was return -1 - that doesn't seem correct - if we return -1, process
1805  * continues in the calling function.
1806  */
1807  return maxdam;
1808 }
1809 
1820 int friendly_fire(object *op, object *hitter) {
1821  object *owner;
1822  int friendlyfire;
1823 
1824  hitter = HEAD(hitter);
1825  friendlyfire = 0;
1826 
1827  if (op->type == PLAYER) {
1828  if (hitter->type == PLAYER && hitter->contr->peaceful == 1)
1829  return 1;
1830 
1831  owner = object_get_owner(hitter);
1832  if (owner != NULL) {
1833  if (owner->type == PLAYER && owner->contr->peaceful == 1)
1834  friendlyfire = 2;
1835  }
1836 
1837  if (hitter->type == SPELL
1838  || hitter->type == POISONING
1839  || hitter->type == DISEASE
1840  || hitter->type == RUNE)
1841  friendlyfire = 0;
1842  }
1843  return friendlyfire;
1844 }
1845 
1869 int hit_player(object *op, int dam, object *hitter, uint32_t type, int full_hit) {
1870  int maxdam = 0, ndam = 0, magic = (type&AT_MAGIC);
1871  int maxattacktype, attacknum;
1872  int body_attack = op->head != NULL; /* Did we hit op's head? */
1873  int simple_attack;
1874  tag_t op_tag, hitter_tag;
1875  int rtn_kill = 0;
1876  int friendlyfire;
1877  object *owner;
1878 
1879  /* Lauwenmark: Handle for plugin attack event */
1880  if (execute_event(op, EVENT_ATTACKED, hitter, hitter->current_weapon ? hitter->current_weapon : hitter, NULL, SCRIPT_FIX_ALL) != 0)
1881  return 0;
1882  FOR_INV_PREPARE(op, inv)
1883  if (execute_event(inv, EVENT_ATTACKED, hitter, hitter->current_weapon ? hitter->current_weapon : hitter, NULL, SCRIPT_FIX_ALL) != 0)
1884  return 0;
1885  FOR_INV_FINISH();
1886 
1887  if (get_attack_mode(&op, &hitter, &simple_attack))
1888  return 0;
1889 
1890  /* very simple: if our target has no_damage 1 set or is wiz, we can't hurt him */
1891  if (QUERY_FLAG(op, FLAG_WIZ) || QUERY_FLAG(op, FLAG_NO_DAMAGE))
1892  return 0;
1893 
1894  op_tag = op->count;
1895  hitter_tag = hitter->count;
1896 
1897  if (body_attack) {
1898  /* slow and paralyze must hit the head. But we don't want to just
1899  * return - we still need to process other attacks the spell still
1900  * might have. So just remove the paralyze and slow attacktypes,
1901  * and keep on processing if we have other attacktypes.
1902  * return if only magic or nothing is left - under normal code
1903  * we don't attack with pure magic if there is another attacktype.
1904  * Only do processing if the initial attacktype includes one of those
1905  * attack so we don't cancel out things like magic bullet.
1906  */
1907  if (type&(AT_PARALYZE|AT_SLOW)) {
1908  type &= ~(AT_PARALYZE|AT_SLOW);
1909  if (!type || type == AT_MAGIC)
1910  return 0;
1911  }
1912  }
1913 
1914  if (!simple_attack && op->type == DOOR) {
1915  object *tmp;
1916 
1917  tmp = object_find_by_type2(op, RUNE, TRAP);
1918  if (tmp != NULL) {
1919  spring_trap(tmp, hitter);
1920  if (object_was_destroyed(hitter, hitter_tag)
1921  || object_was_destroyed(op, op_tag)
1922  || abort_attack(op, hitter, simple_attack))
1923  return 0;
1924  }
1925  }
1926 
1927  if (!QUERY_FLAG(op, FLAG_ALIVE) || op->stats.hp < 0) {
1928  /* FIXME: If a player is killed by a rune in a door, the
1929  * object_was_destroyed() check above doesn't return, and might get here.
1930  */
1931  LOG(llevDebug, "victim (arch %s, name %s) already dead in hit_player()\n", op->arch->name, op->name);
1932  return 0;
1933  }
1934 
1935 #ifdef ATTACK_DEBUG
1936  LOG(llevDebug, "hit player: attacktype %d, dam %d\n", type, dam);
1937 #endif
1938 
1939  if (magic) {
1940  /* basically: dam = dam*(100-op->resist[attacknum])/100;
1941  * in case 0>dam>1, we try to "simulate" a float value-effect */
1942  dam = dam*(100-op->resist[ATNR_MAGIC]);
1943  if (dam >= 100)
1944  dam /= 100;
1945  else
1946  dam = (dam > (rndm(0, 99))) ? 1 : 0;
1947  }
1948 
1949  /* AT_CHAOS here is a weapon or monster. Spells are handled by hit_map
1950  * We don't use shuffle_attack(), because that changes the it in the
1951  * creature structure, and thus is permanent until fix_object() is
1952  * called again. Chaos should change on each attack.
1953  */
1954  if (type&AT_CHAOS) {
1955  type = ATTACKS[RANDOM()%(sizeof(ATTACKS)/sizeof(*ATTACKS))].attacktype|AT_MAGIC;
1956  }
1957 
1958  /* Holyword is really an attacktype modifier (like magic is). If
1959  * holyword is part of an attacktype, then make sure the creature is
1960  * a proper match, otherwise no damage.
1961  */
1962  if (type&AT_HOLYWORD) {
1963  const object *god;
1964 
1965  if ((!hitter->slaying || (!(op->race && strstr(hitter->slaying, op->race))
1966  && !(op->name && strstr(hitter->slaying, op->name))))
1967  && (!QUERY_FLAG(op, FLAG_UNDEAD) || (hitter->title != NULL
1968  && (god = find_god(determine_god(hitter))) != NULL
1969  && god->race != NULL
1970  && strstr(god->race, undead_name) != NULL)))
1971  return 0;
1972  }
1973 
1974  maxattacktype = type; /* initialize this to something */
1975  for (attacknum = 0; attacknum < NROFATTACKS; attacknum++) {
1976  int attacktype;
1977 
1978  attacktype = 1<<attacknum;
1979 
1980  /* Magic isn't really a true attack type - it gets combined with other
1981  * attack types. As such, skip it over. However, if magic is
1982  * the only attacktype in the group, then still attack with it
1983  */
1984  if (attacktype == AT_MAGIC && (type&~AT_MAGIC))
1985  continue;
1986 
1987  /* Go through and hit the player with each attacktype, one by one.
1988  * hit_with_one_attacktype only figures out the damage, doesn't inflict
1989  * it. It will do the appropriate action for attacktypes with
1990  * effects (slow, paralization, etc.
1991  */
1992  if (type&attacktype) {
1993  ndam = hit_with_one_attacktype(op, hitter, dam, attacknum);
1994  /* the >= causes us to prefer messages from special attacks, if
1995  * the damage is equal.
1996  */
1997  if (ndam >= maxdam) {
1998  maxdam = ndam;
1999  maxattacktype = 1<<attacknum;
2000  }
2001  /* Special case: death attack always deals all damage, as it should kill the monster
2002  * right away. */
2003  if (attacktype == AT_DEATH && ndam > 0)
2004  full_hit = 1;
2005  }
2006  }
2007 
2008 
2009  /* if this is friendly fire then do a set % of damage only
2010  * Note - put a check in to make sure this attack is actually
2011  * doing damage - otherwise, the +1 in the coe below will make
2012  * an attack do damage before when it otherwise didn't
2013  * Only reduce damage if not on battlground - if in arena, do
2014  * full damage. Note that it is intentional that the check for
2015  * battleground is inside the friendlyfire if statement - op_on_battleground()
2016  * is a fairly costly function to call, and we don't want to call it for
2017  * every attack - by doing it only for friendlyfire, it shouldn't get called
2018  * that often
2019  */
2020  friendlyfire = friendly_fire(op, hitter);
2021  if (friendlyfire && maxdam) {
2022  if (!op_on_battleground(op, NULL, NULL, NULL)) {
2023  maxdam = ((dam*settings.set_friendly_fire)/100)+1;
2024 #ifdef ATTACK_DEBUG
2025  LOG(llevDebug, "Friendly fire (type:%d setting: %d%) did %d damage dropped to %d\n", friendlyfire, settings.set_friendly_fire, dam, maxdam);
2026 #endif
2027  }
2028  }
2029 
2030  if (!full_hit) {
2031  archetype *at;
2032  unsigned int area = 0;
2033  for (at = op->arch; at != NULL; at = at->more)
2034  area++;
2035 
2036  /* basically: maxdam /= area; we try to "simulate" a float
2037  value-effect */
2038  unsigned int remainder = 100*(maxdam%area)/area;
2039  maxdam /= area;
2040  if (RANDOM()%100 < remainder)
2041  maxdam++;
2042  }
2043 
2044 #ifdef ATTACK_DEBUG
2045  LOG(llevDebug, "Attacktype %d did %d damage\n", type, maxdam);
2046 #endif
2047 
2048  owner = object_get_owner(hitter);
2049  if (owner != NULL) {
2050  if (op->enemy != hitter)
2051  object_set_enemy(op, owner);
2052  } else if (QUERY_FLAG(hitter, FLAG_ALIVE))
2053  if (op->enemy == NULL || rndm(1, 20) == 0)
2054  object_set_enemy(op, hitter);
2055 
2056  if (QUERY_FLAG(op, FLAG_UNAGGRESSIVE) && op->type != PLAYER) {
2057  /* The unaggressives look after themselves 8) */
2058  CLEAR_FLAG(op, FLAG_UNAGGRESSIVE);
2059  monster_npc_call_help(op);
2060  }
2061 
2062  if (magic && did_make_save(op, op->level, 0))
2063  maxdam = maxdam/2;
2064 
2065  attack_message(maxdam, maxattacktype, op, hitter);
2066 
2067  op->stats.hp -= maxdam;
2068 
2069  /* Eneq(@csd.uu.se): Check to see if monster runs away. */
2070  if (op->stats.hp >= 0
2071  && (QUERY_FLAG(op, FLAG_MONSTER) || op->type == PLAYER)
2072  && op->stats.hp < (int16_t)((int32_t)op->run_away * op->stats.maxhp / 100)) {
2073  if (QUERY_FLAG(op, FLAG_MONSTER))
2074  SET_FLAG(op, FLAG_RUN_AWAY);
2075  else
2076  scare_creature(op, hitter);
2077  }
2078 
2079  if (QUERY_FLAG(op, FLAG_TEAR_DOWN)) {
2080  if (maxdam)
2081  tear_down_wall(op);
2082  return maxdam; /* nothing more to do for wall */
2083  }
2084 
2085  /* See if the creature has been killed */
2086  rtn_kill = kill_object(op, maxdam, hitter);
2087  if (rtn_kill != -1)
2088  return rtn_kill;
2089 
2090  /* Used to be ghosthit removal - we now use the ONE_HIT flag. Note
2091  * that before if the player was immune to ghosthit, the monster
2092  * remained - that is no longer the case.
2093  */
2094  if (QUERY_FLAG(hitter, FLAG_ONE_HIT)) {
2095  if (QUERY_FLAG(hitter, FLAG_FRIENDLY))
2096  remove_friendly_object(hitter);
2097  object_remove(hitter);
2098  object_free_drop_inventory(hitter);
2099  /* Lets handle creatures that are splitting now */
2100  } else if (type&AT_PHYSICAL && !QUERY_FLAG(op, FLAG_FREED) && QUERY_FLAG(op, FLAG_SPLITTING)) {
2101  change_object(op);
2102  } else if (type&AT_DRAIN && hitter->type == GRIMREAPER && hitter->value++ > 10) {
2103  object_remove(hitter);
2104  object_free_drop_inventory(hitter);
2105  }
2106  return maxdam;
2107 }
2108 
2119 static void poison_living(object *op, object *hitter, int dam) {
2120  archetype *at = find_archetype("poisoning");
2121  object *tmp = arch_present_in_ob(at, op);
2122  const char *skill;
2123 
2124  if (tmp == NULL) {
2125  tmp = arch_to_object(at);
2126  if (tmp == NULL)
2127  LOG(llevError, "Failed to clone arch poisoning.\n");
2128  else {
2129  tmp = object_insert_in_ob(tmp, op);
2130  /* peterm: give poisoning some teeth. It should
2131  * be able to kill things better than it does:
2132  * damage should be dependent something--I choose to
2133  * do this: if it's a monster, the damage from the
2134  * poisoning goes as the level of the monster/2.
2135  * If anything else, goes as damage.
2136  */
2137 
2138  if (QUERY_FLAG(hitter, FLAG_ALIVE))
2139  tmp->stats.dam += hitter->level/2;
2140  else
2141  tmp->stats.dam = dam;
2142 
2143  object_copy_owner(tmp, hitter); /* so we get credit for poisoning kills */
2144  skill = hitter->skill;
2145  if (!skill && hitter->chosen_skill)
2146  skill = hitter->chosen_skill->name;
2147 
2148  if (skill && skill != tmp->skill) {
2149  if (tmp->skill)
2150  free_string(tmp->skill);
2151  tmp->skill = add_refcount(skill);
2152  }
2153 
2154  tmp->stats.food += dam; /* more damage, longer poisoning */
2155 
2156  if (op->type == PLAYER) {
2157  /* player looses stats, maximum is -10 of each */
2158  tmp->stats.Con = MAX(-(dam/4+1), -10);
2159  tmp->stats.Str = MAX(-(dam/3+2), -10);
2160  tmp->stats.Dex = MAX(-(dam/6+1), -10);
2161  tmp->stats.Int = MAX(-dam/7, -10);
2162  SET_FLAG(tmp, FLAG_APPLIED);
2163  fix_object(op);
2164  draw_ext_info(NDI_UNIQUE, 0, op,
2165  MSG_TYPE_ATTRIBUTE, MSG_TYPE_ATTRIBUTE_BAD_EFFECT_START,
2166  "You suddenly feel very ill.");
2167  }
2168  if (hitter->type == PLAYER)
2169  draw_ext_info_format(NDI_UNIQUE, 0, hitter,
2170  MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_DID_HIT,
2171  "You poison %s.",
2172  op->name);
2173  else {
2174  object *owner;
2175 
2176  owner = object_get_owner(hitter);
2177  if (owner != NULL && owner->type == PLAYER)
2178  draw_ext_info_format(NDI_UNIQUE, 0, owner,
2179  MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_PET_HIT,
2180  "Your %s poisons %s.",
2181  hitter->name, op->name);
2182  }
2183  tmp->speed_left = 0;
2184  }
2185  } else
2186  tmp->stats.food++;
2187 }
2188 
2199 static void slow_living(object *op, object *hitter, int dam) {
2200  archetype *at = find_archetype("slowness");
2201  object *tmp;
2202  // Used to calculate the speed penalty of the slow attempt
2203  int speed_penalty;
2204 
2205  if (at == NULL) {
2206  LOG(llevError, "Can't find slowness archetype.\n");
2207  return; // Bail so we don't segfault
2208  }
2209 
2215  // Higher level slow effects make you slower.
2216  speed_penalty = hitter->level - op->level + random_roll(1, 5, hitter, PREFER_LOW);
2217  // Resistance to slow will also affect how much you are slowed by.
2218  speed_penalty = speed_penalty * (100-op->resist[ATNR_SLOW]) / 100;
2219  // Make sure we actually have a penalty amount. We can assume that op is not immune in this method.
2220  if (speed_penalty < 1)
2221  speed_penalty = 1;
2222  else if (speed_penalty > 30) // Data barrier for stats.exp is 127, but that is huge slowness. Pick something less than that.
2223  speed_penalty = 30;
2224 
2225  tmp = arch_present_in_ob(at, op);
2226  if (tmp == NULL) {
2227  tmp = arch_to_object(at);
2228  tmp->stats.exp = -speed_penalty;
2229  tmp = object_insert_in_ob(tmp, op);
2230  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_ATTRIBUTE, MSG_TYPE_ATTRIBUTE_BAD_EFFECT_START,
2231  "The world suddenly moves very fast!");
2232  }
2233  // If we are hitting for more intense slowness, override the old one.
2234  else if (tmp->stats.exp > -speed_penalty)
2235  {
2236  tmp->stats.exp = -speed_penalty;
2237  tmp->stats.food -= 3; // But also reduce the duration to compensate.
2238  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_ATTRIBUTE, MSG_TYPE_ATTRIBUTE_BAD_EFFECT_START,
2239  "The world moves even faster!");
2240  }
2241  else
2242  tmp->stats.food++;
2243  SET_FLAG(tmp, FLAG_APPLIED);
2244  tmp->speed_left = 0;
2245  fix_object(op);
2246 }
2247 
2258 void confuse_living(object *op, object *hitter, int dam) {
2259  object *tmp;
2260  int maxduration;
2261 
2262  tmp = object_present_in_ob_by_name(FORCE, "confusion", op);
2263  if (!tmp) {
2264  tmp = create_archetype(FORCE_NAME);
2265  tmp = object_insert_in_ob(tmp, op);
2266  }
2267 
2268  /* Duration added per hit and max. duration of confusion both depend
2269  * on the player's resistance
2270  */
2271  tmp->speed = 0.05;
2272  tmp->subtype = FORCE_CONFUSION;
2273  tmp->duration = 8+MAX(1, 5*(100-op->resist[ATNR_CONFUSION])/100);
2274  if (tmp->name)
2275  free_string(tmp->name);
2276  tmp->name = add_string("confusion");
2277  maxduration = MAX(2, 30*(100-op->resist[ATNR_CONFUSION])/100);
2278  if (tmp->duration > maxduration)
2279  tmp->duration = maxduration;
2280 
2281  if (op->type == PLAYER && !QUERY_FLAG(op, FLAG_CONFUSED))
2282  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_ATTRIBUTE, MSG_TYPE_ATTRIBUTE_BAD_EFFECT_START,
2283  "You suddenly feel very confused!");
2284  SET_FLAG(op, FLAG_CONFUSED);
2285 }
2286 
2297 void blind_living(object *op, object *hitter, int dam) {
2298  object *tmp, *owner;
2299  char victim[MAX_BUF];
2300 
2301  /* Save some work if we know it isn't going to affect the player */
2302  if (op->resist[ATNR_BLIND] == 100)
2303  return;
2304 
2305  tmp = object_present_in_ob(BLINDNESS, op);
2306  if (!tmp) {
2307  tmp = create_archetype("blindness");
2308  SET_FLAG(tmp, FLAG_BLIND);
2309  SET_FLAG(tmp, FLAG_APPLIED);
2310  /* use floats so we don't lose too much precision due to rounding errors.
2311  * speed is a float anyways.
2312  */
2313  tmp->speed = tmp->speed*(100.0-(float)op->resist[ATNR_BLIND])/100;
2314 
2315  tmp = object_insert_in_ob(tmp, op);
2316  change_abil(op, tmp); /* Mostly to display any messages */
2317  fix_object(op); /* This takes care of some other stuff */
2318 
2319  owner = object_get_owner(hitter);
2320  if (owner == NULL)
2321  owner = hitter;
2322 
2323  query_name(op, victim, MAX_BUF);
2324  draw_ext_info_format(NDI_UNIQUE, 0, owner, MSG_TYPE_ATTACK, MSG_TYPE_ATTACK_DID_HIT,
2325  "Your attack blinds %s!",
2326  victim);
2327  }
2328  tmp->stats.food += dam;
2329  if (tmp->stats.food > 10)
2330  tmp->stats.food = 10;
2331 }
2332 
2341 void paralyze_living(object *op, int dam) {
2342  float effect, max;
2343 
2344  /* Do this as a float - otherwise, rounding might very well reduce this to 0 */
2345  effect = (float)dam*3.0*(100.0-op->resist[ATNR_PARALYZE])/100;
2346 
2347  if (effect == 0)
2348  return;
2349 
2350  op->speed_left -= FABS(op->speed)*effect;
2351 
2352  /* max number of ticks to be affected for. */
2353  max = (100-op->resist[ATNR_PARALYZE])/2;
2354  if (op->speed_left < -(FABS(op->speed)*max))
2355  op->speed_left = (float)-(FABS(op->speed)*max);
2356  // Set a paralyze flag and print a message to a player if the flag isn't set;
2357  // this tells the player that he/she has been hit by a paralysis attack.
2358  if (!QUERY_FLAG(op, FLAG_PARALYZED)) {
2359  SET_FLAG(op, FLAG_PARALYZED);
2360  if (op->type == PLAYER)
2361  draw_ext_info(NDI_UNIQUE, 0, op, MSG_TYPE_ATTRIBUTE, MSG_TYPE_ATTRIBUTE_BAD_EFFECT_START,
2362  "You limbs stop moving!");
2363  }
2364  /* If the flag is already set, then the paralysis is merely extended.
2365  * At this point, we do nothing.
2366  * It may be worthwhile to give players another message on paralysis extensions.
2367  *
2368  * Daniel Hawkins 2017-08-22
2369  */
2370 }
2371 
2392 static void deathstrike_living(object *op, object *hitter, int *dam) {
2393  int atk_lev, def_lev, kill_lev, roll;
2394 
2395  if (hitter->slaying) {
2396  if (!((QUERY_FLAG(op, FLAG_UNDEAD) && strstr(hitter->slaying, undead_name))
2397  || (op->race && strstr(op->race, hitter->slaying))))
2398  {
2399  *dam = 0; // Don't do damage if we aren't deathstriking them.
2400  return;
2401  }
2402  } else
2403  if (QUERY_FLAG(op, FLAG_UNDEAD))
2404  {
2405  *dam = 0; // Don't do damage if we aren't deathstriking them.
2406  return;
2407  }
2408 
2409  def_lev = op->level;
2410  if (def_lev < 1) {
2411  LOG(llevError, "BUG: arch %s, name %s with level < 1\n", op->arch->name, op->name);
2412  def_lev = 1;
2413  }
2414  /*
2415  * Redo this calculation -- you could essentially only kill creatures less than half your level,
2416  * making death extremely weak at high levels.
2417  * Refactoring to use a d20 roll with a fairly high DC (still dependent on level)
2418  * Also, toss in a resistance-based hit modifier.
2419  * Higher resistance requires higher levels in order to kill with a death attack.
2420  *
2421  * Daniel Hawkins 2018-05-21
2422  */
2423  atk_lev = (hitter->chosen_skill ? hitter->chosen_skill->level : hitter->level);
2424  /* LOG(llevDebug, "Deathstrike - attack level %d, defender level %d\n", atk_lev, def_lev); */
2425 
2426  roll = random_roll(1, 20, hitter, PREFER_HIGH);
2427  kill_lev = roll - 18 + atk_lev; // Use 19+ as a kill for same level and no resistance;
2428  kill_lev = kill_lev * (100 - op->resist[ATNR_DEATH]) / 100; // Do not compress to *= for roundoff reasons.
2429 
2430  // If we hit, then kill them. Otherwise, damage is 0.
2431  if (kill_lev > def_lev) {
2432  *dam = op->stats.hp+10; /* take all hp. they can still save for 1/2 */
2433  /* I think this doesn't really do much. Because of
2434  * integer rounding, this only makes any difference if the
2435  * attack level is double the defender level.
2436  */
2437  *dam *= kill_lev/def_lev;
2438  }
2439  else {
2440  *dam = 0; /* no harm done */
2441  }
2442 }
2443 
2456 static void thrown_item_effect(object *hitter, object *victim) {
2457  if (!QUERY_FLAG(hitter, FLAG_ALIVE)) {
2458  /* May not need a switch for just 2 types, but this makes it
2459  * easier for expansion.
2460  */
2461  switch (hitter->type) {
2462  case POTION:
2463  /* should player get a save throw instead of checking magic protection? */
2464  if (QUERY_FLAG(victim, FLAG_ALIVE)
2465  && !QUERY_FLAG(victim, FLAG_UNDEAD)
2466  && (victim->resist[ATNR_MAGIC] < 60))
2467  (void)ob_apply(hitter, victim, 0);
2468  break;
2469 
2470  case POISON: /* poison drinks */
2471  /* As with potions, should monster get a save? */
2472  if (QUERY_FLAG(victim, FLAG_ALIVE)
2473  && !QUERY_FLAG(victim, FLAG_UNDEAD)
2474  && (victim->resist[ATNR_POISON] < 60))
2475  (void)ob_apply(victim, hitter, 0);
2476  break;
2477 
2478  /* Removed case statements that did nothing.
2479  * food may be poisonous, but monster must be willing to eat it,
2480  * so we don't handle it here.
2481  * Containers should perhaps break open, but that code was disabled.
2482  */
2483  }
2484  }
2485 }
2486 
2496 static int adj_attackroll(object *hitter, object *target) {
2497  object *attacker = hitter;
2498  int adjust = 0;
2499 
2500  /* safety */
2501  if (!target || !hitter || !hitter->map || !target->map || !on_same_map(hitter, target)) {
2502  LOG(llevError, "BUG: adj_attackroll(): hitter and target not on same map\n");
2503  return 0;
2504  }
2505 
2506  /* aimed missiles use the owning object's sight */
2507  if (is_aimed_missile(hitter)) {
2508  attacker = object_get_owner(hitter);
2509  if (attacker == NULL)
2510  attacker = hitter;
2511  /* A player who saves but hasn't quit still could have objects
2512  * owned by him - need to handle that case to avoid crashes.
2513  */
2514  if (QUERY_FLAG(attacker, FLAG_REMOVED))
2515  attacker = hitter;
2516  } else if (!QUERY_FLAG(hitter, FLAG_ALIVE))
2517  return 0;
2518 
2519  /* determine the condtions under which we make an attack.
2520  * Add more cases, as the need occurs. */
2521 
2522  if (!monster_can_see_enemy(attacker, target)) {
2523  /* target is unseen */
2524  if (target->invisible || QUERY_FLAG(attacker, FLAG_BLIND))
2525  adjust -= 10;
2526  /* dark map penalty for the hitter, though xray can help for a player */
2527  else if (target->map && target->map->darkness > 0 && !monster_stand_in_light(target) && (hitter->type != PLAYER || !player_can_view(hitter, target)))
2528  adjust -= target->map->darkness;
2529  }
2530 
2531  if (QUERY_FLAG(attacker, FLAG_SCARED))
2532  adjust -= 3;
2533 
2534  if (QUERY_FLAG(target, FLAG_UNAGGRESSIVE))
2535  adjust += 1;
2536 
2537  if (QUERY_FLAG(target, FLAG_SCARED))
2538  adjust += 1;
2539 
2540  if (QUERY_FLAG(attacker, FLAG_CONFUSED))
2541  adjust -= 3;
2542 
2543  /* if we attack at a different 'altitude' its harder
2544  * Note - only make this adjustment if the target actually
2545  * has a move type. Doors don't (they don't move), and
2546  * this would evaluate as true. If anything, something without
2547  * a move type should be easier to hit.
2548  */
2549  if (target->move_type && (attacker->move_type&target->move_type) == 0)
2550  adjust -= 2;
2551 
2552  return adjust;
2553 }
2554 
2563 static int is_aimed_missile(object *op) {
2564  /* I broke what used to be one big if into a few nested
2565  * ones so that figuring out the logic is at least possible.
2566  */
2567  if (op && (op->move_type&MOVE_FLYING)) {
2568  if (op->type == ARROW || op->type == THROWN_OBJ)
2569  return 1;
2570  else if (op->type == SPELL_EFFECT
2571  && (op->subtype == SP_BULLET || op->subtype == SP_EXPLOSION))
2572  return 1;
2573  }
2574  return 0;
2575 }
draw_ext_info_format
void draw_ext_info_format(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *format,...)
Definition: main.c:315
scare_creature
static void scare_creature(object *target, object *hitter)
Definition: attack.c:1129
spring_trap
void spring_trap(object *trap, object *victim)
Definition: rune.c:205
paralyze_living
void paralyze_living(object *op, int dam)
Definition: attack.c:2341
AT_HOLYWORD
#define AT_HOLYWORD
Definition: attack.h:97
abort_attack
static int abort_attack(object *target, object *hitter, int simple_attack)
Definition: attack.c:718
SOUND_TYPE_HIT
#define SOUND_TYPE_HIT
Definition: newclient.h:312
liv::Int
int8_t Int
Definition: living.h:35
pl
Definition: player.h:92
determine_god
const char * determine_god(object *op)
Definition: gods.c:106
find_archetype
archetype * find_archetype(const char *name)
Definition: arch.c:692
FLAG_DAMNED
#define FLAG_DAMNED
Definition: define.h:318
liv::ac
int8_t ac
Definition: living.h:37
UP_OBJ_FACE
#define UP_OBJ_FACE
Definition: object.h:519
obj::move_type
MoveType move_type
Definition: object.h:424
ATM_KARATE
#define ATM_KARATE
Definition: attack.h:29
drain_stat
void drain_stat(object *op)
Definition: living.c:712
FLAG_ONE_HIT
#define FLAG_ONE_HIT
Definition: define.h:344
AT_ELECTRICITY
#define AT_ELECTRICITY
Definition: attack.h:79
AT_COUNTERSPELL
#define AT_COUNTERSPELL
Definition: attack.h:95
ATM_CRUSH
#define ATM_CRUSH
Definition: attack.h:38
RING
Definition: object.h:185
ATM_PIERCE
#define ATM_PIERCE
Definition: attack.h:33
calc_skill_exp
int64_t calc_skill_exp(const object *who, const object *op, const object *skill)
Definition: skill_util.c:657
AT_DEPLETE
#define AT_DEPLETE
Definition: attack.h:92
AT_GHOSTHIT
#define AT_GHOSTHIT
Definition: attack.h:85
ATM_BLUD
#define ATM_BLUD
Definition: attack.h:39
FLAG_SLEEP
#define FLAG_SLEEP
Definition: define.h:308
name_to_material
materialtype_t * name_to_material(const char *name)
Definition: utils.c:248
obj::race
const char * race
Definition: object.h:318
ATNR_TURN_UNDEAD
#define ATNR_TURN_UNDEAD
Definition: attack.h:62
FLAG_HITBACK
#define FLAG_HITBACK
Definition: define.h:267
attack_message
static void attack_message(int dam, int type, object *op, object *hitter)
Definition: attack.c:432
thrown_item_effect
static void thrown_item_effect(object *, object *)
Definition: attack.c:2456
SET_FLAG
#define SET_FLAG(xyz, p)
Definition: define.h:223
attackmess::level
int level
Definition: attack.h:119
add_refcount
sstring add_refcount(sstring str)
Definition: shstr.c:210
SP_CONE
#define SP_CONE
Definition: spells.h:81
NDI_ALL
#define NDI_ALL
Definition: newclient.h:246
materialt
EXTERN materialtype_t * materialt
Definition: material.h:43
shuffle_attack
void shuffle_attack(object *op, int change_face)
Definition: spell_util.c:1081
pl::title
char title[BIG_NAME]
Definition: player.h:165
FABS
#define FABS(x)
Definition: define.h:22
stick_arrow
static int stick_arrow(object *op, object *tmp)
Definition: attack.c:918
monster_can_see_enemy
int monster_can_see_enemy(object *op, object *enemy)
Definition: monster.c:2569
EVENT_DEATH
#define EVENT_DEATH
Definition: plugin.h:67
object_copy_owner
void object_copy_owner(object *op, object *clone)
Definition: object.c:657
obj::material
uint16_t material
Definition: object.h:347
WEAP_CLEAVE
#define WEAP_CLEAVE
Definition: define.h:80
party_struct
Definition: party.h:10
ARROW
Definition: object.h:117
FLAG_FRIENDLY
#define FLAG_FRIENDLY
Definition: define.h:246
ATNR_DEPLETE
#define ATNR_DEPLETE
Definition: attack.h:65
BIG_NAME
#define BIG_NAME
Definition: define.h:42
_materialtype::save
int8_t save[NROFATTACKS]
Definition: material.h:37
AT_CANCELLATION
#define AT_CANCELLATION
Definition: attack.h:91
free_string
void free_string(sstring str)
Definition: shstr.c:280
WEAP_SLICE
#define WEAP_SLICE
Definition: define.h:81
fix_stopped_item
void fix_stopped_item(object *op, mapstruct *map, object *originator)
Definition: time.c:490
SET_ANIMATION
#define SET_ANIMATION(ob, newanim)
Definition: global.h:169
esrv_update_item
void esrv_update_item(int flags, object *pl, object *op)
Definition: main.c:342
object_get_value
const char * object_get_value(const object *op, const char *const key)
Definition: object.c:4246
ATNR_SLOW
#define ATNR_SLOW
Definition: attack.h:60
obj::duration
int16_t duration
Definition: object.h:403
account_struct::next
struct account_struct * next
Definition: account.c:85
pl::socket
socket_struct socket
Definition: player.h:94
obj::invisible
int16_t invisible
Definition: object.h:360
freearr_x
short freearr_x[SIZEOFFREE]
Definition: object.c:65
PREFER_LOW
#define PREFER_LOW
Definition: define.h:600
RUNE
Definition: object.h:240
obj::slaying
const char * slaying
Definition: object.h:319
FLAG_CONFUSED
#define FLAG_CONFUSED
Definition: define.h:312
free_no_drop
int free_no_drop(object *op)
Definition: time.c:560
tear_down_wall
static void tear_down_wall(object *op)
Definition: attack.c:1080
pl::ranges
object * ranges[range_size]
Definition: player.h:103
obj::subtype
uint8_t subtype
Definition: object.h:339
ROD
Definition: object.h:109
AT_COLD
#define AT_COLD
Definition: attack.h:80
blind_living
void blind_living(object *op, object *hitter, int dam)
Definition: attack.c:2297
obj::hide
uint8_t hide
Definition: object.h:387
liv::exp
int64_t exp
Definition: living.h:46
_materialtype::material
int material
Definition: material.h:36
change_luck
void change_luck(object *op, int value)
Definition: living.c:791
is_aimed_missile
static int is_aimed_missile(object *op)
Definition: attack.c:2563
object_was_destroyed
#define object_was_destroyed(op, old_tag)
Definition: object.h:68
TRUE
#define TRUE
Definition: compat.h:10
GIRDLE
Definition: object.h:223
arch_present_in_ob
object * arch_present_in_ob(const archetype *at, const object *op)
Definition: object.c:3061
FLAG_IS_LIGHTABLE
#define FLAG_IS_LIGHTABLE
Definition: define.h:278
check_exp_loss
int64_t check_exp_loss(const object *op, int64_t exp)
Definition: living.c:1998
stop_item
object * stop_item(object *op)
Definition: time.c:450
AMULET
Definition: object.h:139
FALSE
#define FALSE
Definition: compat.h:11
remove_friendly_object
void remove_friendly_object(object *op)
Definition: friend.c:56
MAX
#define MAX(x, y)
Definition: compat.h:20
object_update
void object_update(object *op, int action)
Definition: object.c:1239
ob_apply
method_ret ob_apply(object *op, object *applier, int aflags)
Definition: ob_methods.c:42
did_make_save_item
static int did_make_save_item(object *op, int type, object *originator)
Definition: attack.c:88
FLAG_TEAR_DOWN
#define FLAG_TEAR_DOWN
Definition: define.h:279
AT_BLIND
#define AT_BLIND
Definition: attack.h:98
find_god
const object * find_god(const char *name)
Definition: gods.c:80
NDI_BLACK
#define NDI_BLACK
Definition: newclient.h:221
EVENT_ATTACKS
#define EVENT_ATTACKS
Definition: plugin.h:66
WEAP_BLUD
#define WEAP_BLUD
Definition: define.h:85
player_can_view
int player_can_view(object *pl, object *op)
Definition: player.c:4137
SCRIPT_FIX_ALL
#define SCRIPT_FIX_ALL
Definition: global.h:361
obj::enemy
struct obj * enemy
Definition: object.h:381
obj::other_arch
struct archt * other_arch
Definition: object.h:413
draw_ext_info
void draw_ext_info(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *message)
Definition: main.c:310
ATM_FIRE
#define ATM_FIRE
Definition: attack.h:27
ATNR_CONFUSION
#define ATNR_CONFUSION
Definition: attack.h:54
archt
Definition: object.h:465
socket_struct::host
char * host
Definition: newserver.h:110
WAND
Definition: object.h:220
MSG_TYPE_APPLY
#define MSG_TYPE_APPLY
Definition: newclient.h:384
Settings::casting_time
uint8_t casting_time
Definition: global.h:266
ATM_WHIP
#define ATM_WHIP
Definition: attack.h:37
FOR_OB_AND_BELOW_FINISH
#define FOR_OB_AND_BELOW_FINISH()
Definition: define.h:789
adj_attackroll
static int adj_attackroll(object *hitter, object *target)
Definition: attack.c:2496
liv::Con
int8_t Con
Definition: living.h:35
MIN
#define MIN(x, y)
Definition: compat.h:17
FLAG_REMOVED
#define FLAG_REMOVED
Definition: define.h:232
liv::hp
int16_t hp
Definition: living.h:39
freearr_y
short freearr_y[SIZEOFFREE]
Definition: object.c:71
pl::party
partylist * party
Definition: player.h:186
FLAG_KNOWN_MAGICAL
#define FLAG_KNOWN_MAGICAL
Definition: define.h:320
AT_TURN_UNDEAD
#define AT_TURN_UNDEAD
Definition: attack.h:89
AT_LIFE_STEALING
#define AT_LIFE_STEALING
Definition: attack.h:100
rndm
int rndm(int min, int max)
Definition: utils.c:162
WEAP_WHIP
#define WEAP_WHIP
Definition: define.h:83
FLAG_UNDEAD
#define FLAG_UNDEAD
Definition: define.h:270
object_set_owner
void object_set_owner(object *op, object *owner)
Definition: object.c:601
obj::discrete_damage
int16_t * discrete_damage
Definition: object.h:435
AT_CHAOS
#define AT_CHAOS
Definition: attack.h:94
MSG_TYPE_ATTACK_PET_DIED
#define MSG_TYPE_ATTACK_PET_DIED
Definition: newclient.h:611
TRAP
Definition: object.h:241
obj::chosen_skill
struct obj * chosen_skill
Definition: object.h:386
object_free_drop_inventory
void object_free_drop_inventory(object *ob)
Definition: object.c:1368
change_abil
int change_abil(object *op, object *tmp)
Definition: living.c:394
obj::title
const char * title
Definition: object.h:317
obj::y
int16_t y
Definition: object.h:326
object_insert_in_map_at
object * object_insert_in_map_at(object *op, mapstruct *m, object *originator, int flag, int x, int y)
Definition: object.c:1921
confuse_living
void confuse_living(object *op, object *hitter, int dam)
Definition: attack.c:2258
liv::maxhp
int16_t maxhp
Definition: living.h:40
NDI_RED
#define NDI_RED
Definition: newclient.h:224
object_replace_insert_in_map
void object_replace_insert_in_map(const char *arch_string, object *op)
Definition: object.c:2425
ATM_ARROW
#define ATM_ARROW
Definition: attack.h:23
SP_BULLET
#define SP_BULLET
Definition: spells.h:79
FLAG_ALIVE
#define FLAG_ALIVE
Definition: define.h:230
kill_player
void kill_player(object *op, const object *killer)
Definition: player.c:3468
ATNR_CANCELLATION
#define ATNR_CANCELLATION
Definition: attack.h:64
MSG_TYPE_VICTIM
#define MSG_TYPE_VICTIM
Definition: newclient.h:392
get_attack_mode
static int get_attack_mode(object **target, object **hitter, int *simple_attack)
Definition: attack.c:682
get_turn_bonus
int get_turn_bonus(int stat)
Definition: living.c:2291
create_archetype
object * create_archetype(const char *name)
Definition: arch.c:617
object_insert_in_ob
object * object_insert_in_ob(object *op, object *where)
Definition: object.c:2690
undead_name
EXTERN const char * undead_name
Definition: global.h:161
obj::speed_left
float speed_left
Definition: object.h:329
is_wraith_pl
int is_wraith_pl(object *op)
Definition: player.c:165
SK_EXP_TOTAL
#define SK_EXP_TOTAL
Definition: skills.h:80
ATNR_PARALYZE
#define ATNR_PARALYZE
Definition: attack.h:61
int16_t
signed short int16_t
Definition: win32.h:160
ATTACKS
EXTERN Chaos_Attacks ATTACKS[22]
Definition: attack.h:134
obj::materialname
const char * materialname
Definition: object.h:346
obj::weight
int32_t weight
Definition: object.h:365
obj::anim_suffix
const char * anim_suffix
Definition: object.h:316
update_all_los
void update_all_los(const mapstruct *map, int x, int y)
Definition: los.c:532
Settings::pk_max_experience
int64_t pk_max_experience
Definition: global.h:310
liv::Wis
int8_t Wis
Definition: living.h:35
ATM_PUNCH
#define ATM_PUNCH
Definition: attack.h:31
FLAG_UNAGGRESSIVE
#define FLAG_UNAGGRESSIVE
Definition: define.h:272
monster_stand_in_light
int monster_stand_in_light(object *op)
Definition: monster.c:2526
monster_npc_call_help
void monster_npc_call_help(object *op)
Definition: monster.c:1831
MSG_TYPE_ADMIN_PLAYER
#define MSG_TYPE_ADMIN_PLAYER
Definition: newclient.h:474
obj::map
struct mapdef * map
Definition: object.h:297
MSG_TYPE_ATTACK_DID_KILL
#define MSG_TYPE_ATTACK_DID_KILL
Definition: newclient.h:610
ATM_SLASH
#define ATM_SLASH
Definition: attack.h:32
ATNR_LIFE_STEALING
#define ATNR_LIFE_STEALING
Definition: attack.h:73
ATNR_DEATH
#define ATNR_DEATH
Definition: attack.h:66
snprintf
#define snprintf
Definition: win32.h:46
MSG_TYPE_ATTRIBUTE
#define MSG_TYPE_ATTRIBUTE
Definition: newclient.h:380
ATM_CLAW
#define ATM_CLAW
Definition: attack.h:30
hit_map
int hit_map(object *op, int dir, uint32_t type, int full_hit)
Definition: attack.c:320
MOVE_FLYING
#define MOVE_FLYING
Definition: define.h:410
FOR_INV_FINISH
#define FOR_INV_FINISH()
Definition: define.h:712
MAXATTACKMESS
#define MAXATTACKMESS
Definition: attack.h:19
liv::dam
int16_t dam
Definition: living.h:45
ATNR_BLIND
#define ATNR_BLIND
Definition: attack.h:71
GOLEM
Definition: object.h:145
FLAG_BLOCKSVIEW
#define FLAG_BLOCKSVIEW
Definition: define.h:269
obj::name
const char * name
Definition: object.h:311
obj::env
struct obj * env
Definition: object.h:293
ATNR_INTERNAL
#define ATNR_INTERNAL
Definition: attack.h:72
ATNR_FEAR
#define ATNR_FEAR
Definition: attack.h:63
WEAP_STAB
#define WEAP_STAB
Definition: define.h:82
archt::more
struct archt * more
Definition: object.h:469
execute_global_event
int execute_global_event(int eventcode,...)
Definition: main.c:369
WEAP_PIERCE
#define WEAP_PIERCE
Definition: define.h:79
MSG_TYPE_VICTIM_WAS_HIT
#define MSG_TYPE_VICTIM_WAS_HIT
Definition: newclient.h:647
INS_NO_WALK_ON
#define INS_NO_WALK_ON
Definition: object.h:570
object_present_in_ob
object * object_present_in_ob(uint8_t type, const object *op)
Definition: object.c:3001
ATM_COLD
#define ATM_COLD
Definition: attack.h:26
_materialtype
Definition: material.h:33
FLAG_PARALYZED
#define FLAG_PARALYZED
Definition: define.h:380
obj::current_weapon
struct obj * current_weapon
Definition: object.h:370
obj::nrof
uint32_t nrof
Definition: object.h:333
ATNR_MAGIC
#define ATNR_MAGIC
Definition: attack.h:50
ATM_CLEAVE
#define ATM_CLEAVE
Definition: attack.h:34
UPD_FLAGS
#define UPD_FLAGS
Definition: newclient.h:290
P_OUT_OF_MAP
#define P_OUT_OF_MAP
Definition: map.h:251
POTION
Definition: object.h:111
obj::contr
struct pl * contr
Definition: object.h:276
AT_FIRE
#define AT_FIRE
Definition: attack.h:78
ATNR_HOLYWORD
#define ATNR_HOLYWORD
Definition: attack.h:70
FLAG_SCARED
#define FLAG_SCARED
Definition: define.h:271
mapdef::darkness
uint8_t darkness
Definition: map.h:346
FORCE_CONFUSION
#define FORCE_CONFUSION
Definition: spells.h:144
op_on_battleground
int op_on_battleground(object *op, int *x, int *y, archetype **trophy)
Definition: player.c:4235
Settings::simple_exp
uint8_t simple_exp
Definition: global.h:259
ATNR_PHYSICAL
#define ATNR_PHYSICAL
Definition: attack.h:49
ATM_WRAITH_FEED
#define ATM_WRAITH_FEED
Definition: attack.h:42
deathstrike_living
static void deathstrike_living(object *op, object *hitter, int *dam)
Definition: attack.c:2392
tag_t
uint32_t tag_t
Definition: object.h:12
ATNR_POISON
#define ATNR_POISON
Definition: attack.h:59
AT_PHYSICAL
#define AT_PHYSICAL
Definition: attack.h:76
obj::speed
float speed
Definition: object.h:328
process_object
int process_object(object *op)
Definition: time.c:794
SPELL
Definition: object.h:214
IS_LIVE
#define IS_LIVE(op)
Definition: define.h:172
on_same_map
int on_same_map(const object *op1, const object *op2)
Definition: map.c:2652
QUERY_FLAG
#define QUERY_FLAG(xyz, p)
Definition: define.h:225
CLEAR_FLAG
#define CLEAR_FLAG(xyz, p)
Definition: define.h:224
HEAD
#define HEAD(op)
Definition: object.h:594
MSG_TYPE_APPLY_UNAPPLY
#define MSG_TYPE_APPLY_UNAPPLY
Definition: newclient.h:597
FLAG_WIZ
#define FLAG_WIZ
Definition: define.h:231
change_exp
void change_exp(object *op, int64_t exp, const char *skill_name, int flag)
Definition: living.c:2100
pl::golem_count
uint32_t golem_count
Definition: player.h:106
MSG_TYPE_ATTACK_FUMBLE
#define MSG_TYPE_ATTACK_FUMBLE
Definition: newclient.h:609
WEAP_CRUSH
#define WEAP_CRUSH
Definition: define.h:84
MAX_BUF
#define MAX_BUF
Definition: define.h:35
MSG_TYPE_ATTACK
#define MSG_TYPE_ATTACK
Definition: newclient.h:385
DOOR
Definition: object.h:126
MSG_TYPE_ADMIN
#define MSG_TYPE_ADMIN
Definition: newclient.h:377
pl::peaceful
uint32_t peaceful
Definition: player.h:131
MSG_TYPE_ATTACK_DID_HIT
#define MSG_TYPE_ATTACK_DID_HIT
Definition: newclient.h:607
obj::x
int16_t x
Definition: object.h:326
WEAP_SLASH
#define WEAP_SLASH
Definition: define.h:78
ATM_DRAIN
#define ATM_DRAIN
Definition: attack.h:24
ATNR_COUNTERSPELL
#define ATNR_COUNTERSPELL
Definition: attack.h:68
ATM_DOOR
#define ATM_DOOR
Definition: attack.h:40
obj::move_slow
MoveType move_slow
Definition: object.h:429
ATNR_DRAIN
#define ATNR_DRAIN
Definition: attack.h:56
obj::skill
const char * skill
Definition: object.h:321
FLAG_RUN_AWAY
#define FLAG_RUN_AWAY
Definition: define.h:280
NUM_SKILLS
#define NUM_SKILLS
Definition: skills.h:71
liv::wc
int8_t wc
Definition: living.h:36
M_IRON
#define M_IRON
Definition: material.h:15
int64_t
signed __int64 int64_t
Definition: win32.h:168
FLAG_READY_WEAPON
#define FLAG_READY_WEAPON
Definition: define.h:335
AT_DRAIN
#define AT_DRAIN
Definition: attack.h:83
EVENT_GKILL
#define EVENT_GKILL
Definition: plugin.h:87
FOR_MAP_FINISH
#define FOR_MAP_FINISH()
Definition: define.h:765
liv::Str
int8_t Str
Definition: living.h:35
obj::resist
int16_t resist[NROFATTACKS]
Definition: object.h:341
FLAG_KNOWN_CURSED
#define FLAG_KNOWN_CURSED
Definition: define.h:321
sstring
const char * sstring
Definition: global.h:40
FLAG_CURSED
#define FLAG_CURSED
Definition: define.h:317
uint32_t
unsigned int uint32_t
Definition: win32.h:162
PLAYER
Definition: object.h:107
POISON
Definition: object.h:113
pl::killer
char killer[BIG_NAME]
Definition: player.h:171
AT_POISON
#define AT_POISON
Definition: attack.h:86
FLAG_NO_DAMAGE
#define FLAG_NO_DAMAGE
Definition: define.h:364
PREFER_HIGH
#define PREFER_HIGH
Definition: define.h:599
obj::attacktype
uint32_t attacktype
Definition: object.h:342
FLAG_GENERATOR
#define FLAG_GENERATOR
Definition: define.h:248
INS_NO_MERGE
#define INS_NO_MERGE
Definition: object.h:568
FLAG_BLIND
#define FLAG_BLIND
Definition: define.h:337
Settings::set_friendly_fire
uint16_t set_friendly_fire
Definition: global.h:271
object_decrease_nrof
object * object_decrease_nrof(object *op, uint32_t i)
Definition: object.c:2505
RANDOM
#define RANDOM()
Definition: define.h:679
cancellation
static void cancellation(object *op)
Definition: attack.c:49
NUM_ANIMATIONS
#define NUM_ANIMATIONS(ob)
Definition: global.h:177
SKILL
Definition: object.h:143
blank_face
New_Face * blank_face
Definition: image.c:39
attack_mess
EXTERN attackmess_t attack_mess[NROFATTACKMESS][MAXATTACKMESS]
Definition: attack.h:131
obj::count
tag_t count
Definition: object.h:299
obj::stats
living stats
Definition: object.h:368
liv::Dex
int8_t Dex
Definition: living.h:35
obj::arch
struct archt * arch
Definition: object.h:412
AT_FEAR
#define AT_FEAR
Definition: attack.h:90
AT_SLOW
#define AT_SLOW
Definition: attack.h:87
obj::type
uint8_t type
Definition: object.h:338
settings
struct Settings settings
Definition: init.c:40
object_set_enemy
void object_set_enemy(object *op, object *enemy)
Definition: object.c:679
FLAG_SPLITTING
#define FLAG_SPLITTING
Definition: define.h:266
check_physically_infect
void check_physically_infect(object *victim, object *hitter)
Definition: disease.c:663
obj::weapontype
uint32_t weapontype
Definition: object.h:371
FLAG_APPLIED
#define FLAG_APPLIED
Definition: define.h:235
NROFATTACKS
#define NROFATTACKS
Definition: attack.h:17
object_merge
object * object_merge(object *op, object *top)
Definition: object.c:1869
out_of_map
int out_of_map(mapstruct *m, int x, int y)
Definition: map.c:2308
execute_event
int execute_event(object *op, int eventcode, object *activator, object *third, const char *message, int fix)
Definition: main.c:364
int32_t
signed int int32_t
Definition: win32.h:159
UPD_NAME
#define UPD_NAME
Definition: newclient.h:293
hit_player
int hit_player(object *op, int dam, object *hitter, uint32_t type, int full_hit)
Definition: attack.c:1869
MSG_TYPE_APPLY_SUCCESS
#define MSG_TYPE_APPLY_SUCCESS
Definition: newclient.h:598
obj::casting_time
int16_t casting_time
Definition: object.h:402
FOR_OB_AND_BELOW_PREPARE
#define FOR_OB_AND_BELOW_PREPARE(op_)
Definition: define.h:785
FORCE_NAME
#define FORCE_NAME
Definition: spells.h:169
AT_MAGIC
#define AT_MAGIC
Definition: attack.h:77
GET_ANIM_ID
#define GET_ANIM_ID(ob)
Definition: global.h:171
add_string
sstring add_string(const char *str)
Definition: shstr.c:124
ATM_BASIC
#define ATM_BASIC
Definition: attack.h:28
ATM_SUFFER
#define ATM_SUFFER
Definition: attack.h:41
FLAG_MONSTER
#define FLAG_MONSTER
Definition: define.h:245
counterspell
void counterspell(object *op, int dir)
Definition: spell_effect.c:2862
attack_ob_simple
static int attack_ob_simple(object *op, object *hitter, int base_dam, int base_wc)
Definition: attack.c:749
get_map_flags
int get_map_flags(mapstruct *oldmap, mapstruct **newmap, int16_t x, int16_t y, int16_t *nx, int16_t *ny)
Definition: map.c:302
obj::inv
struct obj * inv
Definition: object.h:290
NDI_UNIQUE
#define NDI_UNIQUE
Definition: newclient.h:245
apply_anim_suffix
void apply_anim_suffix(object *who, sstring suffix)
Definition: anim.c:318
account_struct::name
char * name
Definition: account.c:77
obj::head
struct obj * head
Definition: object.h:296
ATM_SLICE
#define ATM_SLICE
Definition: attack.h:35
LOG
void LOG(LogLevel logLevel, const char *format,...)
Definition: logger.c:51
did_make_save
int did_make_save(const object *op, int level, int bonus)
Definition: living.c:2199
make_visible
void make_visible(object *op)
Definition: player.c:3944
FLAG_WAS_WIZ
#define FLAG_WAS_WIZ
Definition: define.h:234
_materialtype::next
struct _materialtype * next
Definition: material.h:39
FOR_MAP_PREPARE
#define FOR_MAP_PREPARE(map_, mx_, my_, it_)
Definition: define.h:758
obj::move_block
MoveType move_block
Definition: object.h:425
play_sound_map
void play_sound_map(int8_t sound_type, object *emitter, int dir, const char *action)
Definition: sounds.c:101
obj::run_away
uint8_t run_away
Definition: object.h:384
pl::last_skill_ob
object * last_skill_ob[NUM_SKILLS]
Definition: player.h:137
kill_object
static int kill_object(object *op, int dam, object *hitter)
Definition: attack.c:1529
ATNR_COLD
#define ATNR_COLD
Definition: attack.h:53
MSG_TYPE_ATTACK_PET_HIT
#define MSG_TYPE_ATTACK_PET_HIT
Definition: newclient.h:608
obj::move_slow_penalty
float move_slow_penalty
Definition: object.h:430
query_name
void query_name(const object *op, char *buf, size_t size)
Definition: item.c:626
save_throw_object
void save_throw_object(object *op, uint32_t type, object *originator)
Definition: attack.c:156
share_exp
void share_exp(object *op, int64_t exp, const char *skill, int flag)
Definition: living.c:2229
slow_living
static void slow_living(object *op, object *hitter, int dam)
Definition: attack.c:2199
map_find_by_archetype
object * map_find_by_archetype(mapstruct *m, int x, int y, const archetype *at)
Definition: object.c:2944
mapdef
Definition: map.h:325
random_roll
int random_roll(int min, int max, const object *op, int goodbad)
Definition: utils.c:42
attackmess::buf2
char * buf2
Definition: attack.h:121
USING_SKILL
#define USING_SKILL(op, skill)
Definition: skills.h:86
obj::face
const New_Face * face
Definition: object.h:332
AT_CONFUSION
#define AT_CONFUSION
Definition: attack.h:81
friendly_fire
int friendly_fire(object *op, object *hitter)
Definition: attack.c:1820
FLAG_NO_PICK
#define FLAG_NO_PICK
Definition: define.h:239
ATM_STAB
#define ATM_STAB
Definition: attack.h:36
Settings::pk_max_experience_percent
int pk_max_experience_percent
Definition: global.h:311
IS_ARROW
#define IS_ARROW(op)
Definition: define.h:177
obj::level
int16_t level
Definition: object.h:351
AT_ACID
#define AT_ACID
Definition: attack.h:82
fix_object
void fix_object(object *op)
Definition: living.c:1118
ATNR_CHAOS
#define ATNR_CHAOS
Definition: attack.h:67
ATNR_ACID
#define ATNR_ACID
Definition: attack.h:55
SP_EXPLOSION
#define SP_EXPLOSION
Definition: spells.h:80
AT_DEATH
#define AT_DEATH
Definition: attack.h:93
arch_to_object
object * arch_to_object(archetype *at)
Definition: arch.c:569
EVENT_ATTACKED
#define EVENT_ATTACKED
Definition: plugin.h:65
object_update_speed
void object_update_speed(object *op)
Definition: object.c:1129
obj::value
int32_t value
Definition: object.h:350
attack_ob
int attack_ob(object *op, object *hitter)
Definition: attack.c:903
object_get_owner
object * object_get_owner(object *op)
Definition: object.c:559
obj::magic
int8_t magic
Definition: object.h:348
change_object
void change_object(object *op)
Definition: time.c:587
archt::name
const char * name
Definition: object.h:466
WEAP_HIT
#define WEAP_HIT
Definition: define.h:77
hit_with_one_attacktype
static int hit_with_one_attacktype(object *op, object *hitter, int dam, uint32_t attacknum)
Definition: attack.c:1156
object_present_in_ob_by_name
object * object_present_in_ob_by_name(int type, const char *str, const object *op)
Definition: object.c:3039
fix_stopped_arrow
object * fix_stopped_arrow(object *op)
Definition: time.c:507
poison_living
static void poison_living(object *op, object *hitter, int dam)
Definition: attack.c:2119
FOR_INV_PREPARE
#define FOR_INV_PREPARE(op_, it_)
Definition: define.h:705
Settings::pk_luck_penalty
int16_t pk_luck_penalty
Definition: global.h:253
object_remove
void object_remove(object *op)
Definition: object.c:1654
hit_with_arrow
object * hit_with_arrow(object *op, object *victim)
Definition: attack.c:945
AT_PARALYZE
#define AT_PARALYZE
Definition: attack.h:88
MSG_TYPE_ATTRIBUTE_BAD_EFFECT_START
#define MSG_TYPE_ATTRIBUTE_BAD_EFFECT_START
Definition: newclient.h:558
ATM_ELEC
#define ATM_ELEC
Definition: attack.h:25
attacks
const char *const attacks[NROFATTACKS]
Definition: living.c:129
object_find_by_type2
object * object_find_by_type2(const object *who, int type1, int type2)
Definition: object.c:3928
liv::food
int32_t food
Definition: living.h:47
FLAG_FREED
#define FLAG_FREED
Definition: define.h:233
FORCE
Definition: object.h:224
ATNR_FIRE
#define ATNR_FIRE
Definition: attack.h:51