Crossfire Server, Trunk  R21670
spell_util.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 
19 #include "global.h"
20 
21 #include <assert.h>
22 #include <ctype.h>
23 #include <errno.h>
24 #include <stdlib.h>
25 #include <string.h>
26 
27 #include "living.h"
28 #include "object.h"
29 #include "sounds.h"
30 #include "spells.h"
31 #include "sproto.h"
32 
33 extern const char *const spell_mapping[];
34 
48 object *find_random_spell_in_ob(object *ob, const char *skill) {
49  int k = 0, s;
50 
51  FOR_INV_PREPARE(ob, tmp)
52  if (tmp->type == SPELL && (!skill || tmp->skill == skill))
53  k++;
55 
56  /* No spells, no need to progess further */
57  if (!k)
58  return NULL;
59 
60  s = RANDOM()%k;
61  FOR_INV_PREPARE(ob, tmp)
62  if (tmp->type == SPELL && (!skill || tmp->skill == skill)) {
63  if (!s)
64  return tmp;
65  else
66  s--;
67  }
69 
70  /* Should never get here, but just in case */
71  return NULL;
72 }
73 
94 void set_spell_skill(object *op, object *caster, object *spob, object *dest) {
95  if (dest->skill)
97  if (caster == op && spob->skill)
98  dest->skill = add_refcount(spob->skill);
99  else if (caster->skill)
100  dest->skill = add_refcount(caster->skill);
101 }
102 
109 void check_spells(void) {
110 #ifdef SPELL_DEBUG
111  int i;
112  archetype *at;
113 
114  LOG(llevDebug, "Checking spells...\n");
115 
116  for (at = first_archetype; at; at = at->next) {
117  if (at->clone.type == SPELL) {
118  if (at->clone.skill) {
119  for (i = 0; i < MAX_SKILLS && skill_names[i]; i++)
120  if (!strcmp(skill_names[i], at->clone.skill))
121  break;
122  if (i == MAX_SKILLS || !skill_names[i]) {
123  LOG(llevError, "Spell %s has improper associated skill %s\n", at->name, at->clone.skill);
124  }
125  }
126  /* other_arch is already checked for in the loader */
127  }
128  }
129 
130  i = 0;
131  while (spell_mapping[i]) {
132  if (!find_archetype(spell_mapping[i])) {
133  LOG(llevError, "Unable to find spell mapping %s (%i)\n", spell_mapping[i], i);
134  }
135  i++;
136  }
137  LOG(llevDebug, "Checking spells completed.\n");
138 #endif
139 }
140 
146 void dump_spells(void) {
147  archetype *at;
148  int banner = 0;
149 
150  for (at = first_archetype; at; at = at->next) {
151  if (at->clone.type == SPELL) {
152  fprintf(stderr, "%s:%s:%s:%s:%d\n", at->clone.name ? at->clone.name : "null",
153  at->name, at->clone.other_arch ? at->clone.other_arch->name : "null",
154  at->clone.skill ? at->clone.skill : "null", at->clone.level);
155  }
156  }
157 
158  for (at = first_archetype; at; at = at->next) {
159  if (at->clone.type == SPELL && at->clone.path_attuned == 0) {
160  if (banner == 0) {
161  banner = 1;
162  fprintf(stderr, "Spells with no path set:\n");
163  }
164 
165  fprintf(stderr, "- %s\n", at->clone.name ? at->clone.name : "null");
166  }
167  }
168 }
169 
183 void spell_effect(object *spob, int x, int y, mapstruct *map, object *originator) {
184  if (spob->other_arch != NULL) {
185  object *effect = arch_to_object(spob->other_arch);
186  object_insert_in_map_at(effect, map, originator, 0, x, y);
187  }
188 }
189 
203 int min_casting_level(const object *caster, const object *spell) {
204  int new_level;
205 
206  if (caster->path_denied&spell->path_attuned) {
207  /* This case is not a bug, just the fact that this function is
208  * usually called BEFORE checking for path_deny. -AV
209  */
210  return 1;
211  }
212  new_level = spell->level
213  +((caster->path_repelled&spell->path_attuned) ? +2 : 0)
214  +((caster->path_attuned&spell->path_attuned) ? -2 : 0);
215  return MAX(new_level, 1);
216 }
217 
218 
233 int caster_level(const object *caster, const object *spell) {
234  int level = caster->level;
235 
236  /* If this is a player, try to find the matching skill */
237  if (caster->type == PLAYER && spell->skill) {
238  object* skill = find_applied_skill_by_name(caster, spell->skill);
239  if (skill != NULL) {
240  level = skill->level;
241  } else {
242  level = 0;
243  }
244  }
245  /* Got valid caster level. Now adjust for attunement */
246  level += ((caster->path_repelled&spell->path_attuned) ? -2 : 0)
247  +((caster->path_attuned&spell->path_attuned) ? 2 : 0);
248 
249  /* Always make this at least 1. If this is zero, we get divide by zero
250  * errors in various places.
251  */
252  if (level < 1)
253  level = 1;
254  return level;
255 }
256 
275 int16_t SP_level_spellpoint_cost(object *caster, object *spell, int flags) {
276  int sp, grace, level = caster_level(caster, spell);
277 
279  if (spell->stats.sp && spell->stats.maxsp) {
280  sp = (int)(spell->stats.sp*(1.0+MAX(0, (float)(level-spell->level)/(float)spell->stats.maxsp)));
281  } else
282  sp = spell->stats.sp;
283 
284  sp *= PATH_SP_MULT(caster, spell);
285  if (!sp && spell->stats.sp)
286  sp = 1;
287 
288  if (spell->stats.grace && spell->stats.maxgrace) {
289  grace = (int)(spell->stats.grace*(1.0+MAX(0, (float)(level-spell->level)/(float)spell->stats.maxgrace)));
290  } else
291  grace = spell->stats.grace;
292 
293  grace *= PATH_SP_MULT(caster, spell);
294  if (spell->stats.grace && !grace)
295  grace = 1;
296  } else {
297  sp = spell->stats.sp*PATH_SP_MULT(caster, spell);
298  if (spell->stats.sp && !sp)
299  sp = 1;
300  grace = spell->stats.grace*PATH_SP_MULT(caster, spell);
301  if (spell->stats.grace && !grace)
302  grace = 1;
303  }
304  if (flags == SPELL_HIGHEST)
305  return MAX(sp, grace);
306  else if (flags == SPELL_GRACE)
307  return grace;
308  else if (flags == SPELL_MANA)
309  return sp;
310  else {
311  LOG(llevError, "SP_level_spellpoint_cost: Unknown flags passed: %d\n", flags);
312  return 0;
313  }
314 }
315 
326 int SP_level_dam_adjust(const object *caster, const object *spob) {
327  int level = caster_level(caster, spob);
328  int adj = level-min_casting_level(caster, spob);
329 
330  if (adj < 0)
331  adj = 0;
332  if (spob->dam_modifier)
333  adj /= spob->dam_modifier;
334  else
335  adj = 0;
336  return adj;
337 }
338 
351 int SP_level_duration_adjust(const object *caster, const object *spob) {
352  int level = caster_level(caster, spob);
353  int adj = level-min_casting_level(caster, spob);
354 
355  if (adj < 0)
356  adj = 0;
357  if (spob->duration_modifier)
358  adj /= spob->duration_modifier;
359  else
360  adj = 0;
361 
362  return adj;
363 }
364 
377 int SP_level_range_adjust(const object *caster, const object *spob) {
378  int level = caster_level(caster, spob);
379  int adj = level-min_casting_level(caster, spob);
380 
381  if (adj < 0)
382  adj = 0;
383  if (spob->range_modifier)
384  adj /= spob->range_modifier;
385  else
386  adj = 0;
387 
388  return adj;
389 }
390 
401 int SP_level_wc_adjust(const object *caster, const object *spob) {
402  int level = caster_level(caster, spob);
403  int adj = level - min_casting_level(caster, spob), irate;
404  sstring rate;
405 
406  rate = object_get_value(spob, "wc_increase_rate");
407 
408  if (rate == NULL)
409  return 0;
410 
411  if (adj < 0)
412  adj = 0;
413 
414  irate = atoi(rate);
415  if (irate > 0)
416  adj /= irate;
417  else
418  adj = 0;
419  return adj;
420 }
421 
433 object *check_spell_known(object *op, const char *name) {
434  return object_find_by_type_and_name(op, SPELL, name);
435 }
436 
449 object *lookup_spell_by_name(object *op, const char *spname) {
450  object *spob1 = NULL, *spob2 = NULL;
451  int nummatch = 0;
452 
453  if (spname == NULL)
454  return NULL;
455 
456  /* Try to find the spell. We store the results in spob1
457  * and spob2 - spob1 is only taking the length of
458  * the past spname, spob2 uses the length of the spell name.
459  */
460  FOR_INV_PREPARE(op, spob) {
461  if (spob->type == SPELL) {
462  if (!strncmp(spob->name, spname, strlen(spname))) {
463  if (strlen(spname) == strlen(spob->name))
464  /* Perfect match, return it. */
465  return spob;
466  nummatch++;
467  spob1 = spob;
468  } else if (!strncmp(spob->name, spname, strlen(spob->name))) {
469  /* if spells have ambiguous names, it makes matching
470  * really difficult. (eg, fire and fireball would
471  * fall into this category). It shouldn't be hard to
472  * make sure spell names don't overlap in that fashion.
473  */
474  if (spob2)
475  LOG(llevError, "Found multiple spells with overlapping base names: %s, %s\n", spob2->name, spob->name);
476  spob2 = spob;
477  }
478  }
479  } FOR_INV_FINISH();
480  /* if we have best match, return it. Otherwise, if we have one match
481  * on the loser match, return that, otehrwise null
482  */
483  if (spob2)
484  return spob2;
485  if (spob1 && nummatch == 1)
486  return spob1;
487  return NULL;
488 }
489 
509 int reflwall(mapstruct *m, int x, int y, object *sp_op) {
510  if (OUT_OF_REAL_MAP(m, x, y))
511  return 0;
512  FOR_MAP_PREPARE(m, x, y, op)
513  if (QUERY_FLAG(op, FLAG_REFL_SPELL)
514  && (!QUERY_FLAG(op, FLAG_ALIVE) || (rndm(0, 99)) < 90-(sp_op->level/10)))
515  return 1;
516  FOR_MAP_FINISH();
517  return 0;
518 }
519 
533 int cast_create_obj(object *op, object *new_op, int dir) {
534  mapstruct *m;
535  int16_t sx, sy;
536 
537  if (dir
538  && ((get_map_flags(op->map, &m, op->x+freearr_x[dir], op->y+freearr_y[dir], &sx, &sy)&P_OUT_OF_MAP)
539  || OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(m, sx, sy)))) {
541  "Something is in the way. You cast it at your feet.");
542  dir = 0;
543  }
544  if (dir == 0)
545  object_insert_in_map_at(new_op, op->map, op, INS_BELOW_ORIGINATOR, op->x+freearr_x[dir], op->y+freearr_y[dir]);
546  else
547  object_insert_in_map_at(new_op, op->map, op, 0, op->x+freearr_x[dir], op->y+freearr_y[dir]);
548  return dir;
549 }
550 
569 int ok_to_put_more(mapstruct *m, int16_t x, int16_t y, object *op, uint32_t immune_stop) {
570  int mflags;
571  mapstruct *mp;
572 
573  mp = m;
574  mflags = get_map_flags(m, &mp, x, y, &x, &y);
575 
576  if (mflags&P_OUT_OF_MAP)
577  return 0;
578 
579  if (OB_TYPE_MOVE_BLOCK(op, GET_MAP_MOVE_BLOCK(mp, x, y)))
580  return 0;
581 
582  FOR_MAP_PREPARE(mp, x, y, tmp) {
583  /* If there is a counterspell on the space, and this
584  * object is using magic, don't progess. I believe we could
585  * leave this out and let in progress, and other areas of the code
586  * will then remove it, but that would seem to to use more
587  * resources, and may not work as well if a player is standing
588  * on top of a counterwall spell (may hit the player before being
589  * removed.) On the other hand, it may be more dramatic for the
590  * spell to actually hit the counterwall and be sucked up.
591  */
592  if ((tmp->attacktype&AT_COUNTERSPELL)
593  && (tmp->type != PLAYER)
594  && !QUERY_FLAG(tmp, FLAG_MONSTER)
595  && (tmp->type != WEAPON)
596  && (tmp->type != BOW)
597  && (tmp->type != ARROW)
598  && (tmp->type != GOLEM)
599  && (immune_stop&AT_MAGIC))
600  return 0;
601 
602  /* This is to prevent 'out of control' spells. Basically, this
603  * limits one spell effect per space per spell. This is definitely
604  * needed for performance reasons, and just for playability I believe.
605  * there are no such things as multispaced spells right now, so
606  * we don't need to worry about the head.
607  * We only need to go down this path is maxhp is set on both objects -
608  * otherwise, no reason to check. But if we do check, we need to
609  * do some extra work, looking in the spell_tags[] of each object,
610  * if they have it set.
611  */
612  if (tmp->type == op->type
613  && tmp->subtype == op->subtype
614  && tmp->stats.maxhp
615  && op->stats.maxhp) {
616  if ((tmp->stats.maxhp == op->stats.maxhp)
617  || (tmp->spell_tags && OB_SPELL_TAG_MATCH(tmp, (tag_t)op->stats.maxhp))
618  || (op->spell_tags && OB_SPELL_TAG_MATCH(op, (tag_t)tmp->stats.maxhp))) {
620  return 0;
621  }
622 
623  /* if both objects have spell tags, then if the two tags entries
624  * from either match, that also counts. Need to check
625  * the spell_tags, because 0 values are allowed to match
626  */
627  if (op->spell_tags && tmp->spell_tags) {
628  int i;
629 
630  for (i = 0; i < SPELL_TAG_SIZE; i++) {
631  if (op->spell_tags[i] &&
632  op->spell_tags[i] == tmp->spell_tags[i]) {
634  return 0;
635  }
636  }
637  }
638  }
639  /* Perhaps we should also put checks in for no magic and unholy
640  * ground to prevent it from moving along?
641  */
642  } FOR_MAP_FINISH();
643  /* If it passes the above tests, it must be OK */
644  return 1;
645 }
646 
668 int fire_arch_from_position(object *op, object *caster, int16_t x, int16_t y, int dir, object *spell) {
669  object *tmp;
670  int mflags;
671  mapstruct *m;
672 
673  if (dir < 0 || dir > 8) {
674  LOG(llevError, "Invalid direction %d in fire_arch_from_position for %s\n", dir, spell->name);
675  dir = RANDOM() % 8 + 1;
676  }
677 
678  if (spell->other_arch == NULL)
679  return 0;
680 
681  if (spell->type != SPELL)
682  LOG(llevError, "Unexpected object type %d in fire_arch_from_position for %s\n", spell->type, spell->name);
683 
684  m = op->map;
685  mflags = get_map_flags(m, &m, x, y, &x, &y);
686  if (mflags&P_OUT_OF_MAP) {
687  return 0;
688  }
689 
690  tmp = arch_to_object(spell->other_arch);
691  if (tmp == NULL)
692  return 0;
693 
694  mflags = get_map_flags(m, &tmp->map, x, y, &tmp->x, &tmp->y);
695  if (mflags&P_OUT_OF_MAP) {
697  return 0;
698  }
699 
700  if (spell->subtype == SP_BULLET) {
701  /* peterm: level dependency for bolts */
702  tmp->stats.dam = spell->stats.dam+SP_level_dam_adjust(caster, spell);
703  tmp->attacktype = spell->attacktype;
704  if (spell->slaying)
705  tmp->slaying = add_refcount(spell->slaying);
706 
707  tmp->range = 50;
708 
709  /* Need to store duration/range for the ball to use */
710  tmp->stats.hp = spell->duration+SP_level_duration_adjust(caster, spell);
711  tmp->stats.maxhp = spell->range+SP_level_range_adjust(caster, spell);
712  tmp->dam_modifier = spell->stats.food+SP_level_dam_adjust(caster, spell);
713 
714  tmp->direction = dir;
716 
717  object_set_owner(tmp, op);
718  } else {
719  if (spell->subtype != SP_MAGIC_MISSILE && spell->subtype != SP_MOVING_BALL)
720  LOG(llevError, "Unexpected object subtype %d in fire_arch_from_position for %s\n", spell->subtype, spell->name);
721 
722  /*
723  * Things like firewalls and such can fire even if blocked, since the
724  * origin is themselves which block things...
725  * This fixes bug #3536508.
726  */
727  if (caster->type == PLAYER && OB_TYPE_MOVE_BLOCK(tmp, GET_MAP_MOVE_BLOCK(tmp->map, tmp->x, tmp->y))) {
729  "You can't cast the spell on top of a wall!");
731  return 0;
732  }
733 
734  tmp->stats.dam = spell->stats.dam+SP_level_dam_adjust(caster, spell);
735  tmp->duration = spell->duration+SP_level_duration_adjust(caster, spell);
736  /* code in time.c uses food for some things, duration for others */
737  tmp->stats.food = tmp->duration;
738  tmp->range = spell->range+SP_level_range_adjust(caster, spell);
739  tmp->attacktype = spell->attacktype;
740  if (object_get_owner(op) != NULL)
741  object_copy_owner(tmp, op);
742  else
743  object_set_owner(tmp, op);
744  tmp->level = caster_level(caster, spell);
745  }
746 
747  tmp->direction = dir;
748  set_spell_skill(op, caster, spell, tmp);
749 
750  if (spell->subtype == SP_BULLET) {
751  if (OB_TYPE_MOVE_BLOCK(tmp, GET_MAP_MOVE_BLOCK(tmp->map, tmp->x, tmp->y))) {
752  if (!QUERY_FLAG(tmp, FLAG_REFLECTING)) {
754  return 0;
755  }
756  tmp->direction = absdir(tmp->direction+4);
757  x += DIRX(tmp);
758  y += DIRY(tmp);
759  mflags = get_map_flags(m, &m, x, y, &x, &y);
760  if (mflags&P_OUT_OF_MAP) {
762  return 0;
763  }
764  tmp->x = x;
765  tmp->y = y;
766  tmp->map = m;
767  }
768 
769  tmp = object_insert_in_map_at(tmp, tmp->map, op, 0, tmp->x, tmp->y);
770  if (tmp != NULL)
771  check_bullet(tmp);
772  } else /*if (spell->subtype == SP_MAGIC_MISSILE || spell->subtype == SP_MOVING_BALL) */ {
773  /* needed for AT_HOLYWORD, AT_GODPOWER stuff */
774  if (tmp->attacktype&AT_HOLYWORD || tmp->attacktype&AT_GODPOWER) {
775  if (!tailor_god_spell(tmp, op))
776  return 0;
777  }
779 
780  tmp = object_insert_in_map_at(tmp, tmp->map, op, 0, tmp->x, tmp->y);
781  if (tmp != NULL)
782  ob_process(tmp);
783  }
784 
785  return 1;
786 }
787 
788 /*****************************************************************************
789  *
790  * Code related to rods - perhaps better located in another file?
791  *
792  ****************************************************************************/
793 
800 void regenerate_rod(object *rod) {
801  if (rod->stats.hp < rod->stats.maxhp) {
802  rod->stats.hp += 1+rod->stats.maxhp/10;
803 
804  if (rod->stats.hp > rod->stats.maxhp)
805  rod->stats.hp = rod->stats.maxhp;
806  }
807 }
808 
815 void drain_rod_charge(object *rod) {
816  rod->stats.hp -= SP_level_spellpoint_cost(rod, rod->inv, SPELL_HIGHEST);
817 }
818 
825 void drain_wand_charge(object *wand) {
826  assert(wand->type == WAND);
827 
828  if (!(--wand->stats.food)) {
829  object *tmp;
830  if (wand->arch) {
831  CLEAR_FLAG(wand, FLAG_ANIMATE);
832  wand->face = wand->arch->clone.face;
833  wand->speed = 0;
834  object_update_speed(wand);
835  }
836  tmp = object_get_player_container(wand);
837  if (tmp)
838  esrv_update_item(UPD_ANIM, tmp, wand);
839  }
840 }
841 
852 object *find_target_for_friendly_spell(object *op, int dir) {
853  object *tmp;
854  mapstruct *m;
855  int16_t x, y;
856  int mflags;
857 
858  /* I don't really get this block - if op isn't a player or rune,
859  * we then make the owner of this object the target.
860  * The owner could very well be no where near op.
861  */
862  if (op->type != PLAYER && op->type != RUNE) {
863  tmp = object_get_owner(op);
864  /* If the owner does not exist, or is not a monster, than apply the spell
865  * to the caster.
866  */
867  if (!tmp || !QUERY_FLAG(tmp, FLAG_MONSTER))
868  tmp = op;
869  } else {
870  m = op->map;
871  x = op->x+freearr_x[dir];
872  y = op->y+freearr_y[dir];
873 
874  mflags = get_map_flags(m, &m, x, y, &x, &y);
875 
876  if (mflags&P_OUT_OF_MAP)
877  tmp = NULL;
878  else {
879  for (tmp = GET_MAP_OB(m, x, y); tmp != NULL; tmp = tmp->above) {
880  if (tmp->type == PLAYER)
881  break;
882  }
883  }
884  }
885  /* didn't find a player there, look in current square for a player */
886  if (tmp == NULL)
887  FOR_MAP_PREPARE(op->map, op->x, op->y, tmp) {
888  if (tmp->type == PLAYER)
889  return tmp;
890  /* Don't forget to browse inside transports ! - gros 2006/07/25 */
891  if (tmp->type == TRANSPORT) {
892  object *inv;
893 
894  for (inv = tmp->inv; inv; inv = inv->below) {
895  if ((inv->type == PLAYER) && (op == inv))
896  return inv;
897  }
898  }
899  } FOR_MAP_FINISH();
900  return tmp;
901 }
902 
903 
904 
925 int spell_find_dir(mapstruct *m, int x, int y, object *exclude) {
926  int i;
927  int16_t nx, ny;
928  int owner_type = 0, mflags;
929  object *tmp;
930  mapstruct *mp;
931  int dirs[SIZEOFFREE];
932 
933  if (exclude != NULL) {
934  exclude = HEAD(exclude);
935  owner_type = exclude->type;
936  }
937 
938  get_search_arr(dirs);
939  for (i = 1; i < SIZEOFFREE; i++) {
940  nx = x+freearr_x[dirs[i]];
941  ny = y+freearr_y[dirs[i]];
942  mp = m;
943  mflags = get_map_flags(m, &mp, nx, ny, &nx, &ny);
944  if (mflags&(P_OUT_OF_MAP|P_BLOCKSVIEW))
945  continue;
946 
947  for (tmp = GET_MAP_OB(mp, nx, ny); tmp != NULL; tmp = tmp->above) {
948  object *head;
949 
950  head = HEAD(tmp);
951  if ((owner_type != PLAYER || QUERY_FLAG(head, FLAG_MONSTER) || QUERY_FLAG(head, FLAG_GENERATOR) || (head->type == PLAYER && op_on_battleground(head, NULL, NULL, NULL)))
952  && (owner_type == PLAYER || head->type == PLAYER)
953  && head != exclude
954  && can_see_monsterP(m, x, y, dirs[i])) {
955  return freedir[dirs[i]];
956  }
957  }
958  }
959  return -1; /* flag for "keep going the way you were" */
960 }
961 
962 
963 
977 static int put_a_monster(object *op, const char *monstername) {
978  object *tmp, *head = NULL, *prev = NULL;
979  archetype *at;
980  int dir;
981 
982  /* Handle cases where we are passed a bogus mosntername */
983  at = find_archetype(monstername);
984  if (at == NULL)
985  return 0;
986 
987  /* find a free square nearby
988  * first we check the closest square for free squares
989  */
990 
991  dir = object_find_first_free_spot(&at->clone, op->map, op->x, op->y);
992  if (dir != -1) {
993  /* This is basically grabbed for generate monster. Fixed 971225 to
994  * insert multipart monsters properly
995  */
996  while (at != NULL) {
997  tmp = arch_to_object(at);
998  tmp->x = op->x+freearr_x[dir]+at->clone.x;
999  tmp->y = op->y+freearr_y[dir]+at->clone.y;
1000  tmp->map = op->map;
1001  if (head) {
1002  tmp->head = head;
1003  prev->more = tmp;
1004  }
1005  if (!head)
1006  head = tmp;
1007  prev = tmp;
1008  at = at->more;
1009  }
1010 
1011  if (head->randomitems)
1012  create_treasure(head->randomitems, head, GT_INVISIBLE, op->map->difficulty, 0);
1013 
1014  object_insert_in_map_at(head, op->map, op, 0, op->x, op->y);
1015 
1016  /* thought it'd be cool to insert a burnout, too.*/
1017  tmp = create_archetype("burnout");
1018  object_insert_in_map_at(tmp, op->map, op, 0, op->x+freearr_x[dir], op->y+freearr_y[dir]);
1019  return 1;
1020  } else {
1021  return 0;
1022  }
1023 }
1024 
1043 int summon_hostile_monsters(object *op, int n, const char *monstername) {
1044  int i, put = 0;
1045 
1046  for (i = 0; i < n; i++)
1047  put += put_a_monster(op, monstername);
1048 
1049  return put;
1050 }
1051 
1052 
1077 void shuffle_attack(object *op, int change_face) {
1078  int i;
1079 
1080  i = rndm(0, 21);
1082  if (change_face) {
1083  SET_ANIMATION(op, ATTACKS[i].face);
1084  }
1085 }
1086 
1087 
1098 static void prayer_failure(object *op, int failure, int power) {
1099  const char *godname;
1100  object *tmp;
1101 
1102  godname = determine_god(op);
1103  if (!strcmp(godname, "none"))
1104  godname = "Your spirit";
1105 
1106  if (failure <= -20 && failure > -40) { /* wonder */
1108  "%s gives a sign to renew your faith.",
1109  godname);
1111  cast_cone(op, op, 0, tmp);
1113  } else if (failure <= -40 && failure > -60) { /* confusion */
1115  "Your diety touches your mind!");
1116  confuse_living(op, op, 99);
1117  } else if (failure <= -60 && failure > -150) { /* paralysis */
1119  "%s requires you to pray NOW. You comply, ignoring all else.",
1120  godname);
1121 
1122  paralyze_living(op, 99);
1123  } else if (failure <= -150) { /* blast the immediate area */
1124  tmp = create_archetype(GOD_POWER);
1126  "%s smites you!",
1127  godname);
1128  /* Put a cap on power - this is effectively cost of the spell minus
1129  * characters current grace. Thus, if spell costs 30 grace and
1130  * character has -100 grace, this is cast as a level 130 spell.
1131  * Things start to break in those cases.
1132  */
1133  cast_magic_storm(op, tmp, power > 50 ? 50 : power);
1134  }
1135 }
1136 
1149 void spell_failure(object *op, int failure, int power, object *skill) {
1150  object *tmp;
1151 
1153  return;
1154 
1155  if (failure <= -20 && failure > -40) { /* wonder */
1157  "Your spell causes an unexpected effect.");
1159  cast_cone(op, op, 0, tmp);
1161  } else if (failure <= -40 && failure > -60) { /* confusion */
1163  "Your magic recoils on you, making you confused!");
1164  confuse_living(op, op, 99);
1165  } else if (failure <= -60 && failure > -80) { /* paralysis */
1167  "Your magic stuns you!");
1168  paralyze_living(op, 99);
1169  } else if (failure <= -80) { /* blast the immediate area */
1170  object *tmp;
1171 
1172  /* Safety check to make sure we don't get any mana storms in scorn */
1173  if (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL)&P_NO_MAGIC) {
1175  "The magic warps and you are turned inside out!");
1176  hit_player(op, 9998, op, AT_INTERNAL, 1);
1177  } else {
1179  "You lose control of the mana! The uncontrolled magic blasts you!");
1181  tmp->level = skill->level;
1182 
1183  /* increase the area of destruction a little for more powerful spells */
1184  tmp->range += isqrt(power);
1185 
1186  if (power > 25)
1187  tmp->stats.dam = 25+isqrt(power);
1188  else
1189  tmp->stats.dam = power; /* nasty recoils! */
1190 
1191  tmp->stats.maxhp = tmp->count;
1192  if (tmp->stats.maxhp == 0)
1193  tmp->stats.maxhp = 1;
1194  object_insert_in_map_at(tmp, op->map, NULL, 0, op->x, op->y);
1195  }
1196  }
1197 }
1198 
1207 static int can_be_transmuted_to_flower(object *op) {
1208  if (op->invisible)
1209  return 0;
1210 
1211  if (op->type == POTION || op->type == SCROLL || op->type == WAND || op->type == ROD || op->type == WEAPON)
1212  return 1;
1213 
1214  return 0;
1215 }
1216 
1229 static void transmute_item_to_flower(object *op) {
1230  object *force;
1231  object *item;
1232  object *flower;
1233  object *first = NULL;
1234  int count = 0;
1235  char name[HUGE_BUF];
1236 
1237  FOR_INV_PREPARE(op, item)
1238  if (can_be_transmuted_to_flower(item)) {
1239  if (!first)
1240  first = item;
1241  count++;
1242  }
1243  FOR_INV_FINISH();
1244 
1245  if (count == 0)
1246  return;
1247 
1248  count = rndm(0, count-1);
1249  for (item = first; item; item = item->below) {
1250  if (can_be_transmuted_to_flower(item)) {
1251  count--;
1252  if (count < 0)
1253  break;
1254  }
1255  }
1256 
1257  if (!item)
1258  return;
1259 
1260  force = create_archetype(FORCE_NAME);
1261  force->duration = 100+rndm(0, 10)*100;
1263  force->speed = 1;
1264  object_update_speed(force);
1265 
1266  flower = create_archetype("flowers_permanent");
1267 
1268  if (QUERY_FLAG(item, FLAG_APPLIED))
1270  object_remove(item);
1271  flower->weight = item->nrof ? ((int32_t)item->nrof)*item->weight : item->weight;
1272  item->weight = 0;
1273  esrv_del_item(op->contr, item);
1274  object_insert_in_ob(item, force);
1275 
1276  query_short_name(item, name, HUGE_BUF);
1279  "Your %s turns to a flower!",
1280  name);
1281 
1282  object_insert_in_ob(force, flower);
1283  flower = object_insert_in_ob(flower, op);
1284  esrv_send_item(op, flower);
1285 }
1286 
1297 static void swap_random_stats(object *op) {
1298  object *force;
1299  int first, second;
1300 
1301  first = RANDOM()%NUM_STATS;
1302  second = RANDOM()%(NUM_STATS-1);
1303  if (second >= first)
1304  second++;
1305 
1308  "You suddenly feel really weird!");
1309 
1310  force = create_archetype(FORCE_NAME);
1311  force->duration = 100+rndm(0, 10)*100;
1312  force->speed = 1;
1313  SET_FLAG(force, FLAG_APPLIED);
1314  set_attr_value(&force->stats, second, get_attr_value(&op->stats, first)-get_attr_value(&op->stats, second));
1315  set_attr_value(&force->stats, first, get_attr_value(&op->stats, second)-get_attr_value(&op->stats, first));
1316  object_update_speed(force);
1317  object_insert_in_ob(force, op);
1318  change_abil(op, force);
1319  fix_object(op);
1320 }
1321 
1332 static void handle_spell_confusion(object *op) {
1333  switch (RANDOM()%2) {
1334  case 0:
1336  break;
1337 
1338  case 1:
1339  swap_random_stats(op);
1340  break;
1341  }
1342 }
1343 
1351 static int spell_consume_items(object *op, const object *spell_ob) {
1352  sstring requirements;
1353  char *copy;
1354  char *ingredients[10];
1355  object *found[10];
1356  int count, i;
1357  uint32_t nrof[10];
1358  char name_ob[MAX_BUF];
1359  const char *name2;
1360 
1361  if (op->type != PLAYER)
1362  return 1;
1363 
1364  requirements = object_get_value(spell_ob, "casting_requirements");
1365  if (!requirements)
1366  /* no special requirements */
1367  return 1;
1368 
1369  /* find items */
1370  copy = strdup_local(requirements);
1371  count = split_string(copy, ingredients, 10, ',');
1372 
1373  /* first pass, find items */
1374  for (i = 0; i < count; i++) {
1375  nrof[i] = 0;
1376  found[i] = NULL;
1377  while (isdigit(*ingredients[i])) {
1378  nrof[i] = 10*nrof[i]+(*(ingredients[i])-'0');
1379  ingredients[i]++;
1380  }
1381  if (nrof[i] == 0)
1382  nrof[i] = 1;
1383  while (*ingredients[i] == ' ')
1384  ingredients[i]++;
1385 
1386  /* now find item in op's inv */
1387  FOR_INV_PREPARE(op, check) {
1388 
1389  if (check->title == NULL)
1390  name2 = check->name;
1391  else {
1392  snprintf(name_ob, sizeof(name_ob), "%s %s", check->name, check->title);
1393  name2 = name_ob;
1394  }
1395 
1396  if (strcmp(name2, ingredients[i]) == 0) {
1397  found[i] = check;
1398  break;
1399  }
1400  } FOR_INV_FINISH();
1401 
1402  if (found[i] == NULL) {
1405  "Casting this spell requires %s, but you don't have any.",
1406  ingredients[i]);
1407  free(copy);
1408  return 0;
1409  }
1410 
1411  if (found[i]->nrof < nrof[i]) {
1414  "Casting this spell requires %d %s, but you only have %d.",
1415  nrof[i], found[i]->name_pl, found[i]->nrof);
1416  free(copy);
1417  return 0;
1418  }
1419  }
1420 
1421  free(copy);
1422 
1423  /* ok, found ingredients, remove'em */
1424  for (i = 0; i < count; i++) {
1425  object_decrease_nrof(found[i], nrof[i]);
1426  }
1427 
1428  /* all right, spell can be cast */
1429  return 1;
1430 }
1431 
1467 int cast_spell(object *op, object *caster, int dir, object *spell_ob, char *stringarg) {
1468  const char *godname;
1469  int success = 0, mflags, cast_level = 0;
1470  rangetype old_shoottype;
1471  object *skill = NULL;
1472  int confusion_effect = 0;
1473  float cost_multiplier = 1.0f;
1474 
1475  old_shoottype = op->contr ? op->contr->shoottype : range_none;
1476 
1477  if (!spell_ob) {
1478  LOG(llevError, "cast_spell: null spell object passed\n");
1479  return 0;
1480  }
1481  godname = determine_god(op);
1482  if (!strcmp(godname, "none"))
1483  godname = "A random spirit";
1484 
1485  /* the caller should set caster to op if appropriate */
1486  if (!caster) {
1487  LOG(llevError, "cast_spell: null caster object passed\n");
1488  return 0;
1489  }
1490  if (spell_ob->anim_suffix)
1491  apply_anim_suffix(caster, spell_ob->anim_suffix);
1492 
1493  /* Handle some random effect if confused. */
1494  if (QUERY_FLAG(op, FLAG_CONFUSED) && caster == op && op->type == PLAYER) {
1495  if (rndm(0, 5) < 4) {
1496  spell_ob = find_random_spell_in_ob(op, NULL);
1499  "In your confused state, you're not sure of what you cast!");
1500  } else
1501  /* We fall through to deplate sp/gr, and do some checks. */
1502  confusion_effect = 1;
1503  }
1504 
1505  /* if caster is a spell casting object, this normally shouldn't be
1506  * an issue, because they don't have any spellpaths set up.
1507  */
1508  if ((caster->path_denied&spell_ob->path_attuned) && !QUERY_FLAG(caster, FLAG_WIZ)) {
1510  "That spell path is denied to you.");
1511  return 0;
1512  }
1513 
1514 
1515  mflags = get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL);
1516 
1517  /* See if we can cast a spell here. If the caster and op are
1518  * not alive, then this would mean that the mapmaker put the
1519  * objects on the space - presume that they know what they are
1520  * doing.
1521  */
1522  if (spell_ob->type == SPELL
1523  && caster->type != POTION
1524  && !QUERY_FLAG(op, FLAG_WIZCAST)
1525  && (QUERY_FLAG(caster, FLAG_ALIVE) || QUERY_FLAG(op, FLAG_ALIVE))
1526  && !QUERY_FLAG(op, FLAG_MONSTER)
1527  && (((mflags&P_NO_MAGIC) && spell_ob->stats.sp) || ((mflags&P_NO_CLERIC) && spell_ob->stats.grace))) {
1528  if (op->type != PLAYER)
1529  return 0;
1530 
1532 
1533  if ((mflags&P_NO_CLERIC) && spell_ob->stats.grace)
1535  "This ground is unholy! %s ignores you.",
1536  godname);
1537  else
1538  switch (op->contr->shoottype) {
1539  case range_magic:
1541  "Something blocks your spellcasting.");
1542  break;
1543 
1544  case range_misc:
1546  "Something blocks the magic of your item.");
1547  break;
1548  case range_golem:
1550  "Something blocks the magic of your scroll.");
1551  break;
1552 
1553  default:
1554  break;
1555  }
1556  return 0;
1557  }
1558 
1559  /* if it is a player casting the spell, and they are really casting it
1560  * (vs it coming from a wand, scroll, or whatever else), do some
1561  * checks. We let monsters do special things - eg, they
1562  * don't need the skill, bypass level checks, etc. The monster function
1563  * should take care of that.
1564  * Remove the wiz check here and move it further down - some spells
1565  * need to have the right skill pointer passed, so we need to
1566  * at least process that code.
1567  */
1568  if (op->type == PLAYER && op == caster) {
1569  cast_level = caster_level(caster, spell_ob);
1570  if (spell_ob->skill) {
1571  skill = find_skill_by_name(op, spell_ob->skill);
1572  if (!skill) {
1575  "You need the skill %s to cast %s.",
1576  spell_ob->skill, spell_ob->name);
1577  return 0;
1578  }
1579  if (min_casting_level(op, spell_ob) > cast_level && !QUERY_FLAG(op, FLAG_WIZ)) {
1581  "You lack enough skill to cast that spell.");
1582  return 0;
1583  }
1584  }
1585  /* If the caster is the wiz, they don't ever fail, and don't have
1586  * to have sufficient grace/mana.
1587  */
1588  if (!QUERY_FLAG(op, FLAG_WIZ)) {
1589  if (SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA)
1590  && SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA) > op->stats.sp) {
1592  "You don't have enough mana.");
1593  return 0;
1594  }
1595  if (SP_level_spellpoint_cost(caster, spell_ob, SPELL_GRACE)
1596  && SP_level_spellpoint_cost(caster, spell_ob, SPELL_GRACE) > op->stats.grace) {
1597  if (random_roll(0, op->stats.Wis-1, op, PREFER_HIGH)+op->stats.grace-10*SP_level_spellpoint_cost(caster, spell_ob, SPELL_GRACE)/op->stats.maxgrace > 0) {
1600  "%s grants your prayer, though you are unworthy.",
1601  godname);
1602  } else {
1603  prayer_failure(op, op->stats.grace, SP_level_spellpoint_cost(caster, spell_ob, SPELL_GRACE)-op->stats.grace);
1606  "%s ignores your prayer.",
1607  godname);
1608  return 0;
1609  }
1610  }
1611 
1612  /* player/monster is trying to cast the spell. might fumble it */
1613  if (spell_ob->stats.grace
1614  && random_roll(0, 99, op, PREFER_HIGH) < (get_cleric_chance(op->stats.Wis) * spell_ob->level/MAX(1, op->level))) {
1615  play_sound_player_only(op->contr, SOUND_TYPE_SPELL, spell_ob, 0, "fumble");
1617  "You fumble the spell.");
1618  if (settings.casting_time == TRUE) {
1619  op->casting_time = -1;
1620  }
1621  op->stats.grace -= random_roll(1, SP_level_spellpoint_cost(caster, spell_ob, SPELL_GRACE), op, PREFER_LOW);
1622  object *bungle = create_archetype(ARCH_SPELL_BUNGLE);
1623  if (bungle->arch != NULL) {
1624  cast_create_obj(op, bungle, 0);
1625  } else {
1626  LOG(llevError, "cast_spell: Could not create spell_bungle arch\n");
1627  }
1628  return 0;
1629  } else if (spell_ob->stats.sp) {
1630  int failure = random_roll(0, 199, op, PREFER_HIGH)-op->contr->encumbrance+op->level-spell_ob->level+35;
1631 
1632  if (failure < 0) {
1633  draw_ext_info(NDI_UNIQUE, 0, op,
1635  "You bungle the spell because you have too much heavy equipment in use.");
1637  spell_failure(op, failure, SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA), skill);
1638  op->contr->shoottype = old_shoottype;
1639  op->stats.sp -= random_roll(0, SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA), op, PREFER_LOW);
1640  object *bungle = create_archetype(ARCH_SPELL_BUNGLE);
1641  if (bungle->arch != NULL) {
1642  cast_create_obj(op, bungle, 0);
1643  } else {
1644  LOG(llevError, "cast_spell: Could not create spell_bungle arch\n");
1645  }
1646  return 0;
1647  }
1648  }
1649 
1650  /* ensure the potentially required items are eaten */
1651  if (!spell_consume_items(op, spell_ob))
1652  /* already warned by the function */
1653  return 0;
1654  }
1655  }
1656 
1657  if (caster == op && caster->type ==PLAYER && settings.casting_time == TRUE && spell_ob->type == SPELL) {
1658  if (op->casting_time == -1) { /* begin the casting */
1659  op->casting_time = spell_ob->casting_time*PATH_TIME_MULT(op, spell_ob);
1660  op->spell = spell_ob;
1661  /* put the stringarg into the object struct so that when the
1662  * spell is actually cast, it knows about the stringarg.
1663  * necessary for the invoke command spells.
1664  */
1665  if (stringarg) {
1666  op->spellarg = strdup_local(stringarg);
1667  } else
1668  op->spellarg = NULL;
1669  return 0;
1670  } else if (op->casting_time != 0) {
1671  if (op->type == PLAYER)
1673  "You are casting!");
1674  return 0;
1675  } else { /* casting_time == 0 */
1676  op->casting_time = -1;
1677  spell_ob = op->spell;
1678  stringarg = op->spellarg;
1679  }
1680  } else {
1681  if (!QUERY_FLAG(caster, FLAG_WIZ)) {
1682  /* Take into account how long it takes to cast the spell.
1683  * if the player is casting it, then we use the time in
1684  * the spell object. If it is a spell object, have it
1685  * take two ticks. Things that cast spells on the players
1686  * behalf (eg, altars, and whatever else) shouldn't cost
1687  * the player any time.
1688  * Ignore casting time for firewalls
1689  */
1690  if (caster == op && caster->type != FIREWALL) {
1691  op->speed_left -= spell_ob->casting_time*PATH_TIME_MULT(op, spell_ob)*FABS(op->speed);
1692  /* Other portions of the code may also decrement the speed of the player, so
1693  * put a lower limit so that the player isn't stuck here too long
1694  */
1695  if ((spell_ob->casting_time > 0)
1696  && op->speed_left < -spell_ob->casting_time*PATH_TIME_MULT(op, spell_ob)*FABS(op->speed))
1697  op->speed_left = -spell_ob->casting_time*PATH_TIME_MULT(op, spell_ob)*FABS(op->speed);
1698  } else if (caster->type == WAND
1699  || caster->type == ROD
1700  || caster->type == POTION
1701  || caster->type == SCROLL) {
1702  op->speed_left -= 2*FABS(op->speed);
1703  }
1704  }
1705  }
1706 
1707  /* We want to try to find the skill to properly credit exp.
1708  * for spell casting objects, the exp goes to the skill the casting
1709  * object requires.
1710  */
1711  if (op != caster && !skill && caster->skill && !QUERY_FLAG(op, FLAG_MONSTER)) {
1712  skill = find_skill_by_name(op, caster->skill);
1713  if (!skill) {
1714  char name[MAX_BUF];
1715 
1716  query_name(caster, name, MAX_BUF);
1719  "You lack the skill %s to use the %s",
1720  caster->skill, name);
1721  return 0;
1722  }
1723  change_skill(op, skill, 0); /* needed for proper exp credit */
1724  }
1725 
1726  /* Need to get proper ownership for spells cast via runes - these are not
1727  * the normal 'rune of fire', but rather the magic runes that let the player
1728  * put some other spell into the rune (glyph, firetrap, magic rune, etc)
1729  */
1730  if (caster->type == RUNE) {
1731  object *owner = object_get_owner(caster);
1732 
1733  if (owner)
1734  skill = find_skill_by_name(owner, caster->skill);
1735  }
1736 
1737  if (confusion_effect) {
1738  /* If we get here, the confusion effect was 'random effect', so do it and bail out. */
1741  "In your confused state, you can't control the magic!");
1743 
1744  /* Still subtract full grace and sp. */
1745  if (op->type == PLAYER && op == caster && !QUERY_FLAG(caster, FLAG_WIZ)) {
1746  op->stats.grace -= SP_level_spellpoint_cost(caster, spell_ob, SPELL_GRACE);
1747  op->stats.sp -= SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA);
1748  }
1749 
1750  return 0;
1751  }
1752 
1753  play_sound_map(SOUND_TYPE_SPELL, caster, dir, spell_ob->name);
1754 
1755  switch (spell_ob->subtype) {
1756  /* The order of case statements is same as the order they show up
1757  * in in spells.h.
1758  */
1759  case SP_RAISE_DEAD:
1760  success = cast_raise_dead_spell(op, caster, spell_ob, dir, stringarg);
1761  break;
1762 
1763  case SP_RUNE:
1764  success = write_rune(op, caster, spell_ob, dir, stringarg);
1765  break;
1766 
1767  case SP_MAKE_MARK:
1768  success = write_mark(op, spell_ob, stringarg);
1769  break;
1770 
1771  case SP_BOLT:
1772  success = fire_bolt(op, caster, dir, spell_ob);
1773  break;
1774 
1775  case SP_BULLET:
1776  success = fire_arch_from_position(op, caster, op->x+freearr_x[dir], op->y+freearr_y[dir], dir, spell_ob);
1777  break;
1778 
1779  case SP_CONE:
1780  success = cast_cone(op, caster, dir, spell_ob);
1781  break;
1782 
1783  case SP_BOMB:
1784  success = create_bomb(op, caster, dir, spell_ob);
1785  break;
1786 
1787  case SP_WONDER:
1788  success = cast_wonder(op, caster, dir, spell_ob);
1789  break;
1790 
1791  case SP_SMITE:
1792  success = cast_smite_spell(op, caster, dir, spell_ob);
1793  break;
1794 
1795  case SP_MAGIC_MISSILE:
1796  success = fire_arch_from_position(op, caster, op->x, op->y, dir, spell_ob);
1797  break;
1798 
1799  case SP_SUMMON_GOLEM:
1800  success = pets_summon_golem(op, caster, dir, spell_ob);
1801  if (success || op->contr == NULL)
1802  old_shoottype = range_golem;
1803  else
1804  /*
1805  * if the spell failed (something in the way for instance),
1806  * don't change the range so the player can try easily after that
1807  */
1808  old_shoottype = op->contr->shoottype;
1809  break;
1810 
1811  case SP_DIMENSION_DOOR:
1812  /* dimension door needs the actual caster, because that is what is
1813  * moved.
1814  */
1815  success = dimension_door(op, caster, spell_ob, dir);
1816  break;
1817 
1818  case SP_MAGIC_MAPPING:
1819  if (op->type == PLAYER) {
1820  spell_effect(spell_ob, op->x, op->y, op->map, op);
1821  draw_magic_map(op);
1822  success = 1;
1823  } else
1824  success = 0;
1825  break;
1826 
1827  case SP_MAGIC_WALL:
1828  success = magic_wall(op, caster, dir, spell_ob);
1829  break;
1830 
1831  case SP_DESTRUCTION:
1832  success = cast_destruction(op, caster, spell_ob);
1833  break;
1834 
1835  case SP_PERCEIVE_SELF:
1836  success = perceive_self(op);
1837  break;
1838 
1839  case SP_WORD_OF_RECALL:
1840  success = cast_word_of_recall(op, caster, spell_ob);
1841  break;
1842 
1843  case SP_INVISIBLE:
1844  success = cast_invisible(op, caster, spell_ob);
1845  break;
1846 
1847  case SP_PROBE:
1848  if (op != caster)
1849  cast_level = caster->level;
1850  else
1851  cast_level = skill != NULL ? skill->level : op->level;
1852  success = probe(op, caster, spell_ob, dir, cast_level);
1853  break;
1854 
1855  case SP_HEALING:
1856  success = cast_heal(op, caster, spell_ob, dir);
1857  break;
1858 
1859  case SP_CREATE_FOOD:
1860  success = cast_create_food(op, caster, spell_ob, dir, stringarg);
1861  break;
1862 
1863  case SP_EARTH_TO_DUST:
1864  success = cast_earth_to_dust(op, caster, spell_ob);
1865  break;
1866 
1867  case SP_CHANGE_ABILITY:
1868  success = cast_change_ability(op, caster, spell_ob, dir, 0);
1869  break;
1870 
1871  case SP_BLESS:
1872  success = cast_bless(op, caster, spell_ob, dir);
1873  break;
1874 
1875  case SP_CURSE:
1876  success = cast_curse(op, caster, spell_ob, dir);
1877  break;
1878 
1879  case SP_SUMMON_MONSTER:
1880  success = pets_summon_object(op, caster, spell_ob, dir, stringarg);
1881  if (!success) {
1882  cost_multiplier = 0.0f;
1883  }
1884  break;
1885 
1886  case SP_CHARGING:
1887  success = recharge(op, caster, spell_ob);
1888  break;
1889 
1890  case SP_POLYMORPH:
1891 #if 0
1892  /* Not great, but at least provide feedback so if players do have
1893  * polymorph (ie, find it as a preset item or left over from before
1894  * it was disabled), they get some feedback.
1895  */
1897  "The spell fizzles");
1898  success = 0;
1899 #else
1900  success = cast_polymorph(op, caster, spell_ob, dir);
1901 #endif
1902  break;
1903 
1904  case SP_ALCHEMY:
1905  success = alchemy(op, caster, spell_ob);
1906  break;
1907 
1908  case SP_REMOVE_CURSE:
1909  success = remove_curse(op, caster, spell_ob);
1910  break;
1911 
1912  case SP_IDENTIFY:
1913  success = cast_identify(op, caster, spell_ob);
1914  break;
1915 
1916  case SP_DETECTION:
1917  success = cast_detection(op, caster, spell_ob);
1918  break;
1919 
1920  case SP_MOOD_CHANGE:
1921  success = mood_change(op, caster, spell_ob);
1922  break;
1923 
1924  case SP_MOVING_BALL:
1925  if (spell_ob->path_repelled
1926  && (spell_ob->path_repelled&caster->path_attuned) != spell_ob->path_repelled) {
1928  "You lack the proper attunement to cast %s",
1929  spell_ob->name);
1930  success = 0;
1931  } else
1932  success = fire_arch_from_position(op, caster, op->x, op->y, dir, spell_ob);
1933  break;
1934 
1935  case SP_SWARM:
1936  success = fire_swarm(op, caster, spell_ob, dir);
1937  break;
1938 
1939  case SP_CHANGE_MANA:
1940  success = cast_transfer(op, caster, spell_ob, dir);
1941  break;
1942 
1943  case SP_DISPEL_RUNE:
1944  /* in rune.c */
1945  success = dispel_rune(op, caster, spell_ob, skill, dir);
1946  break;
1947 
1948  case SP_CREATE_MISSILE:
1949  success = cast_create_missile(op, caster, spell_ob, dir, stringarg);
1950  break;
1951 
1952  case SP_CONSECRATE:
1953  success = cast_consecrate(op, caster, spell_ob);
1954  break;
1955 
1956  case SP_ANIMATE_WEAPON:
1957  success = animate_weapon(op, caster, spell_ob, dir);
1958  old_shoottype = range_golem;
1959  break;
1960 
1961  case SP_LIGHT:
1962  success = cast_light(op, caster, spell_ob, dir);
1963  break;
1964 
1965  case SP_CHANGE_MAP_LIGHT:
1966  success = cast_change_map_lightlevel(op, caster, spell_ob);
1967  break;
1968 
1969  case SP_FAERY_FIRE:
1970  success = cast_destruction(op, caster, spell_ob);
1971  break;
1972 
1973  case SP_CAUSE_DISEASE:
1974  success = cast_cause_disease(op, caster, spell_ob, dir);
1975  break;
1976 
1977  case SP_AURA:
1978  success = create_aura(op, caster, spell_ob);
1979  break;
1980 
1981  case SP_TOWN_PORTAL:
1982  success = cast_create_town_portal(op, caster, spell_ob, dir);
1983  break;
1984 
1985  case SP_ITEM_CURSE_BLESS:
1986  success = cast_item_curse_or_curse(op, caster, spell_ob);
1987  break;
1988 
1989  case SP_ELEM_SHIELD:
1990  success = create_aura(op, caster, spell_ob);
1991  break;
1992 
1993  default:
1994  LOG(llevError, "cast_spell: Unhandled spell subtype %d\n", spell_ob->subtype);
1995  }
1996 
1997  /* Subtract grace and sp. */
1998  if (op->type == PLAYER && op == caster && !QUERY_FLAG(caster, FLAG_WIZ)) {
1999  op->stats.grace -= (int)(0.5 + cost_multiplier * SP_level_spellpoint_cost(caster, spell_ob, SPELL_GRACE));
2000  op->stats.sp -= (int)(0.5 + cost_multiplier * SP_level_spellpoint_cost(caster, spell_ob, SPELL_MANA));
2001  }
2002 
2003  /* FIXME - we need some better sound suppport */
2004  /* free the spell arg */
2005  if (settings.casting_time == TRUE) {
2006  free(stringarg);
2007  stringarg = NULL;
2008  }
2009  /* perhaps a bit of a hack, but if using a wand, it has to change the skill
2010  * to something like use_magic_item, but you really want to be able to fire
2011  * it again.
2012  */
2013  if (op->contr)
2014  op->contr->shoottype = old_shoottype;
2015 
2016  return success;
2017 }
2018 
2025 void store_spell_expiry(object *spell) {
2026  /* Keep when to warn the player of expiration */
2027  char dur[10];
2028  int i = spell->duration/5;
2029 
2030  if (!i)
2031  i = 1;
2032  snprintf(dur, sizeof(dur), "%d", i);
2033  object_set_value(spell, "spell_expiry_warn_1", dur, 1);
2034  i = i/5;
2035  if (i > 0) {
2036  snprintf(dur, sizeof(dur), "%d", i);
2037  object_set_value(spell, "spell_expiry_warn_2", dur, 1);
2038  }
2039 }
2040 
2050 void check_spell_expiry(object *spell) {
2051  const char *key;
2052 
2053  if (!spell->env || !IS_PLAYER(spell->env))
2054  return;
2055 
2056  key = object_get_value(spell, "spell_expiry_warn_1");
2057  if (key != NULL) {
2058  if (spell->duration == atoi(key)) {
2060  "The effects of your %s are draining out.", spell->name);
2061  return;
2062  }
2063  }
2064  key = object_get_value(spell, "spell_expiry_warn_2");
2065  if (key != NULL) {
2066  if (spell->duration == atoi(key)) {
2068  "The effects of your %s are about to expire.", spell->name);
2069  return;
2070  }
2071  }
2072 }
2073 
2081 void rod_adjust(object *rod) {
2082  /*
2083  * Add 50 to both level an divisor to keep prices a little
2084  * more reasonable. Otherwise, a high level version of a
2085  * low level spell can be worth tons a money (eg, level 20
2086  * rod, level 2 spell = 10 time multiplier). This way, the
2087  * value are a bit more reasonable.
2088  */
2089  rod->value = rod->value*rod->inv->value*(rod->level+50)/(rod->inv->level+50);
2090 
2091  /*
2092  * Maxhp is used to denote how many 'charges' the rod holds
2093  * before.
2094  */
2095  rod->stats.maxhp = MAX(rod->stats.maxhp, 2)*SP_level_spellpoint_cost(rod, rod->inv, SPELL_HIGHEST);
2096  rod->stats.hp = rod->stats.maxhp;
2097 }
void draw_ext_info_format(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *format,...)
Definition: main.c:316
#define AP_UNAPPLY
Definition: define.h:612
object * object_find_by_type_and_name(const object *who, int type, const char *name)
Definition: object.c:3887
#define AT_HOLYWORD
Definition: attack.h:97
void set_attr_value(living *stats, int attr, int8_t value)
Definition: living.c:219
int apply_manual(object *op, object *tmp, int aflag)
Definition: apply.c:598
void drain_rod_charge(object *rod)
Definition: spell_util.c:815
const char * determine_god(object *op)
Definition: gods.c:106
archetype * find_archetype(const char *name)
Definition: arch.c:695
object * lookup_spell_by_name(object *op, const char *spname)
Definition: spell_util.c:449
#define ARCH_SPELL_BUNGLE
Definition: object.h:583
#define MSG_TYPE_ITEM_CHANGE
Definition: newclient.h:640
#define SP_BOLT
Definition: spells.h:78
#define INS_BELOW_ORIGINATOR
Definition: object.h:572
#define MSG_TYPE_ITEM
Definition: newclient.h:388
int change_skill(object *who, object *new_skill, int flag)
Definition: skill_util.c:340
const char * skill_names[MAX_SKILLS]
Definition: skill_util.c:58
#define SP_MAKE_MARK
Definition: spells.h:77
#define AT_COUNTERSPELL
Definition: attack.h:95
uint8_t dam_modifier
Definition: object.h:410
object * find_applied_skill_by_name(const object *op, const char *name)
Definition: living.c:1915
int cast_raise_dead_spell(object *op, object *caster, object *spell, int dir, const char *arg)
Definition: resurrection.c:181
struct Statistics statistics
Definition: init.c:98
#define SP_CAUSE_DISEASE
Definition: spells.h:119
void spell_failure(object *op, int failure, int power, object *skill)
Definition: spell_util.c:1149
void apply_anim_suffix(object *who, const char *suffix)
Definition: anim.c:318
void esrv_send_item(object *pl, object *op)
Definition: main.c:340
#define SET_FLAG(xyz, p)
Definition: define.h:223
sstring add_refcount(sstring str)
Definition: shstr.c:210
#define SP_TOWN_PORTAL
Definition: spells.h:121
#define SP_CONE
Definition: spells.h:81
#define SP_BLESS
Definition: spells.h:99
object * find_target_for_friendly_spell(object *op, int dir)
Definition: spell_util.c:852
#define FABS(x)
Definition: define.h:22
Definition: object.h:221
int cast_change_ability(object *op, object *caster, object *spell_ob, int dir, int silent)
void object_copy_owner(object *op, object *clone)
Definition: object.c:657
#define SP_CHANGE_MAP_LIGHT
Definition: spells.h:117
#define UPD_ANIM
Definition: newclient.h:294
#define strdup_local
Definition: compat.h:25
tag_t * spell_tags
Definition: object.h:438
#define AT_INTERNAL
Definition: attack.h:99
int reflwall(mapstruct *m, int x, int y, object *sp_op)
Definition: spell_util.c:509
#define SP_CHANGE_ABILITY
Definition: spells.h:98
uint8_t spellpoint_level_depend
Definition: global.h:275
Definition: object.h:117
#define P_NO_MAGIC
Definition: map.h:227
int8_t range
Definition: object.h:408
#define SP_MOVING_BALL
Definition: spells.h:109
int cast_bless(object *op, object *caster, object *spell_ob, int dir)
#define SP_AURA
Definition: spells.h:120
#define MSG_TYPE_SPELL
Definition: newclient.h:387
#define SPELL_GRACE
Definition: spells.h:59
void get_search_arr(int *search_arr)
Definition: object.c:3363
int fire_arch_from_position(object *op, object *caster, int16_t x, int16_t y, int dir, object *spell)
Definition: spell_util.c:668
#define MSG_TYPE_SPELL_FAILURE
Definition: newclient.h:628
int spell_find_dir(mapstruct *m, int x, int y, object *exclude)
Definition: spell_util.c:925
int16_t maxgrace
Definition: living.h:45
#define SP_ANIMATE_WEAPON
Definition: spells.h:115
int SP_level_duration_adjust(const object *caster, const object *spob)
Definition: spell_util.c:351
#define HUGE_BUF
Definition: define.h:37
int SP_level_range_adjust(const object *caster, const object *spob)
Definition: spell_util.c:377
#define SET_ANIMATION(ob, newanim)
Definition: global.h:167
void esrv_update_item(int flags, object *pl, object *op)
Definition: main.c:343
const char * object_get_value(const object *op, const char *const key)
Definition: object.c:4125
struct treasureliststruct * randomitems
Definition: object.h:388
int cast_smite_spell(object *op, object *caster, int dir, object *spell)
Definition: spell_attack.c:546
#define MSG_TYPE_SPELL_INFO
Definition: newclient.h:634
static int spell_consume_items(object *op, const object *spell_ob)
Definition: spell_util.c:1351
object clone
Definition: object.h:472
int16_t duration
Definition: object.h:406
int16_t invisible
Definition: object.h:362
short freearr_x[SIZEOFFREE]
Definition: object.c:65
#define PREFER_LOW
Definition: define.h:601
uint8_t duration_modifier
Definition: object.h:407
rangetype shoottype
Definition: player.h:99
Definition: object.h:240
Definition: object.h:119
#define DIRX(xyz)
Definition: define.h:478
int ok_to_put_more(mapstruct *m, int16_t x, int16_t y, object *op, uint32_t immune_stop)
Definition: spell_util.c:569
int isqrt(int n)
Definition: utils.c:586
int16_t SP_level_spellpoint_cost(object *caster, object *spell, int flags)
Definition: spell_util.c:275
const char * slaying
Definition: object.h:319
#define FLAG_CONFUSED
Definition: define.h:312
int cast_word_of_recall(object *op, object *caster, object *spell_ob)
Definition: spell_effect.c:916
#define MSG_TYPE_SKILL_MISSING
Definition: newclient.h:582
uint8_t subtype
Definition: object.h:341
Definition: object.h:109
#define SPELL_WONDER
Definition: spells.h:163
struct obj * above
Definition: object.h:288
#define PATH_TIME_MULT(op, spell)
Definition: spells.h:152
method_ret ob_process(object *op)
Definition: ob_methods.c:68
#define OUT_OF_REAL_MAP(M, X, Y)
Definition: map.h:217
#define TRUE
Definition: compat.h:10
int freedir[SIZEOFFREE]
Definition: object.c:83
void draw_magic_map(object *pl)
Definition: info.c:440
int8_t get_attr_value(const living *stats, int attr)
Definition: living.c:314
#define FALSE
Definition: compat.h:11
object * check_spell_known(object *op, const char *name)
Definition: spell_util.c:433
uint32_t path_attuned
Definition: object.h:345
#define MAX(x, y)
Definition: compat.h:20
int create_bomb(object *op, object *caster, int dir, object *spell)
Definition: spell_attack.c:447
int16_t sp
Definition: living.h:42
#define FLAG_REFLECTING
Definition: define.h:262
#define SP_CREATE_MISSILE
Definition: spells.h:113
uint32_t path_repelled
Definition: object.h:346
struct archt * other_arch
Definition: object.h:416
int recharge(object *op, object *caster, object *spell_ob)
Definition: spell_effect.c:80
#define SP_HEALING
Definition: spells.h:95
int absdir(int d)
Definition: object.c:3493
void draw_ext_info(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *message)
Definition: main.c:311
Definition: object.h:467
static int can_be_transmuted_to_flower(object *op)
Definition: spell_util.c:1207
Definition: object.h:220
#define MSG_TYPE_APPLY
Definition: newclient.h:384
uint8_t casting_time
Definition: global.h:271
#define MSG_TYPE_VICTIM_SPELL
Definition: newclient.h:651
#define SP_WORD_OF_RECALL
Definition: spells.h:92
int16_t maxsp
Definition: living.h:43
int16_t hp
Definition: living.h:40
#define DIRY(xyz)
Definition: define.h:479
int caster_level(const object *caster, const object *spell)
Definition: spell_util.c:233
int cast_cone(object *op, object *caster, int dir, object *spell)
Definition: spell_attack.c:297
int cast_create_food(object *op, object *caster, object *spell_ob, int dir, const char *stringarg)
Definition: spell_effect.c:622
void rod_adjust(object *rod)
Definition: spell_util.c:2081
short freearr_y[SIZEOFFREE]
Definition: object.c:71
void check_bullet(object *op)
Definition: spell_attack.c:217
#define NDI_NAVY
Definition: newclient.h:223
void create_treasure(treasurelist *t, object *op, int flag, int difficulty, int tries)
Definition: treasure.c:488
#define LOOSE_MANA
Definition: spells.h:162
void esrv_del_item(player *pl, object *ob)
Definition: main.c:356
int summon_hostile_monsters(object *op, int n, const char *monstername)
Definition: spell_util.c:1043
int rndm(int min, int max)
Definition: utils.c:162
int probe(object *op, object *caster, object *spell_ob, int dir, int level)
Definition: spell_effect.c:700
void object_set_owner(object *op, object *owner)
Definition: object.c:604
int object_set_value(object *op, const char *key, const char *value, int add_key)
Definition: object.c:4248
void object_free_drop_inventory(object *ob)
Definition: object.c:1316
int change_abil(object *op, object *tmp)
Definition: living.c:395
int16_t y
Definition: object.h:327
object * object_insert_in_map_at(object *op, mapstruct *m, object *originator, int flag, int x, int y)
Definition: object.c:1838
int16_t maxhp
Definition: living.h:41
int cast_item_curse_or_curse(object *op, object *caster, object *spell_ob)
#define AT_GODPOWER
Definition: attack.h:96
int cast_curse(object *op, object *caster, object *spell_ob, int dir)
Definition: spell_attack.c:800
int fire_swarm(object *op, object *caster, object *spell, int dir)
static void swap_random_stats(object *op)
Definition: spell_util.c:1297
#define SP_PERCEIVE_SELF
Definition: spells.h:91
void object_update_turn_face(object *op)
Definition: object.c:1069
Definition: object.h:118
uint32_t path_denied
Definition: object.h:347
#define SP_BULLET
Definition: spells.h:79
#define FLAG_ALIVE
Definition: define.h:230
void confuse_living(object *op, object *hitter, int dam)
Definition: attack.c:2271
#define AP_IGNORE_CURSE
Definition: define.h:619
#define FLAG_REFL_SPELL
Definition: define.h:275
#define MSG_TYPE_VICTIM
Definition: newclient.h:392
#define SP_ITEM_CURSE_BLESS
Definition: spells.h:123
struct obj * spell
Definition: object.h:411
object * create_archetype(const char *name)
Definition: arch.c:620
void store_spell_expiry(object *spell)
Definition: spell_util.c:2025
int8_t direction
Definition: object.h:336
object * object_insert_in_ob(object *op, object *where)
Definition: object.c:2591
int cast_create_town_portal(object *op, object *caster, object *spell, int dir)
#define SP_MOOD_CHANGE
Definition: spells.h:108
float speed_left
Definition: object.h:330
signed short int16_t
Definition: win32.h:160
EXTERN Chaos_Attacks ATTACKS[22]
Definition: attack.h:134
int32_t weight
Definition: object.h:367
static void handle_spell_confusion(object *op)
Definition: spell_util.c:1332
const char * anim_suffix
Definition: object.h:316
uint8_t range_modifier
Definition: object.h:409
static bool IS_PLAYER(object *op)
Definition: object.h:596
#define SP_BOMB
Definition: spells.h:82
int8_t Wis
Definition: living.h:36
struct mapdef * map
Definition: object.h:297
#define snprintf
Definition: win32.h:46
static void transmute_item_to_flower(object *op)
Definition: spell_util.c:1229
#define MSG_TYPE_APPLY_ERROR
Definition: newclient.h:596
#define SP_WONDER
Definition: spells.h:83
int perceive_self(object *op)
#define FOR_INV_FINISH()
Definition: define.h:714
void set_spell_skill(object *op, object *caster, object *spob, object *dest)
Definition: spell_util.c:94
int pets_summon_golem(object *op, object *caster, int dir, object *spob)
Definition: pets.c:648
int cast_light(object *op, object *caster, object *spell, int dir)
int16_t dam
Definition: living.h:46
int cast_create_obj(object *op, object *new_op, int dir)
Definition: spell_util.c:533
#define MSG_TYPE_SPELL_ERROR
Definition: newclient.h:631
void drain_wand_charge(object *wand)
Definition: spell_util.c:825
Definition: object.h:145
const char * name
Definition: object.h:311
struct obj * env
Definition: object.h:293
int write_mark(object *op, object *spell, const char *msg)
void regenerate_rod(object *rod)
Definition: spell_util.c:800
#define OB_SPELL_TAG_MATCH(op, count)
Definition: object.h:93
#define SP_SMITE
Definition: spells.h:84
struct obj * below
Definition: object.h:287
struct archt * more
Definition: object.h:471
const char *const spell_mapping[]
static int put_a_monster(object *op, const char *monstername)
Definition: spell_util.c:977
#define SP_ALCHEMY
Definition: spells.h:104
object * find_random_spell_in_ob(object *ob, const char *skill)
Definition: spell_util.c:48
uint32_t nrof
Definition: object.h:334
#define OB_TYPE_MOVE_BLOCK(ob1, type)
Definition: define.h:447
#define AP_NOPRINT
Definition: define.h:623
void paralyze_living(object *op, int dam)
Definition: attack.c:2354
#define SIZEOFFREE
Definition: define.h:154
#define P_OUT_OF_MAP
Definition: map.h:251
#define GET_MAP_MOVE_BLOCK(M, X, Y)
Definition: map.h:192
Definition: object.h:111
struct pl * contr
Definition: object.h:276
#define GOD_POWER
Definition: spells.h:164
#define SP_INVISIBLE
Definition: spells.h:93
#define SP_CHARGING
Definition: spells.h:102
#define MSG_TYPE_SKILL_FAILURE
Definition: newclient.h:585
#define SP_DESTRUCTION
Definition: spells.h:90
int op_on_battleground(object *op, int *x, int *y, archetype **trophy)
Definition: player.c:4306
int cast_detection(object *op, object *caster, object *spell)
void cast_magic_storm(object *op, object *tmp, int lvl)
Definition: spell_effect.c:45
#define FREE_AND_CLEAR_STR(xyz)
Definition: global.h:205
char * spellarg
Definition: object.h:412
uint32_t tag_t
Definition: object.h:12
#define SP_DETECTION
Definition: spells.h:107
float speed
Definition: object.h:329
Definition: object.h:214
int cast_wonder(object *op, object *caster, int dir, object *spell_ob)
Definition: spell_effect.c:978
#define SP_RUNE
Definition: spells.h:76
#define QUERY_FLAG(xyz, p)
Definition: define.h:225
#define CLEAR_FLAG(xyz, p)
Definition: define.h:224
#define HEAD(op)
Definition: object.h:594
int cast_invisible(object *op, object *caster, object *spell_ob)
Definition: spell_effect.c:804
#define FLAG_WIZ
Definition: define.h:231
int write_rune(object *op, object *caster, object *spell, int dir, const char *runename)
Definition: rune.c:50
void shuffle_attack(object *op, int change_face)
Definition: spell_util.c:1077
int cast_consecrate(object *op, object *caster, object *spell)
#define MAX_BUF
Definition: define.h:35
#define SP_SWARM
Definition: spells.h:110
int cast_transfer(object *op, object *caster, object *spell, int dir)
int16_t x
Definition: object.h:327
#define SP_IDENTIFY
Definition: spells.h:106
#define SP_EARTH_TO_DUST
Definition: spells.h:97
int16_t encumbrance
Definition: player.h:179
const char * skill
Definition: object.h:321
int dimension_door(object *op, object *caster, object *spob, int dir)
int object_find_first_free_spot(const object *ob, mapstruct *m, int x, int y)
Definition: object.c:3320
uint16_t difficulty
Definition: map.h:343
int cast_destruction(object *op, object *caster, object *spell_ob)
Definition: spell_attack.c:707
static const flag_definition flags[]
#define FOR_MAP_FINISH()
Definition: define.h:767
#define SP_DIMENSION_DOOR
Definition: spells.h:87
#define SP_CHANGE_MANA
Definition: spells.h:111
const char * sstring
Definition: global.h:40
#define SPELL_TAG_SIZE
Definition: object.h:81
unsigned int uint32_t
Definition: win32.h:162
Definition: object.h:107
void check_spells(void)
Definition: spell_util.c:109
#define SP_CURSE
Definition: spells.h:100
#define SP_POLYMORPH
Definition: spells.h:103
int tailor_god_spell(object *spellop, object *caster)
Definition: gods.c:1314
#define FLAG_ANIMATE
Definition: define.h:242
int cast_cause_disease(object *op, object *caster, object *spell, int dir)
#define PREFER_HIGH
Definition: define.h:600
uint32_t attacktype
Definition: object.h:344
#define FLAG_GENERATOR
Definition: define.h:248
int cast_heal(object *op, object *caster, object *spell, int dir)
object * object_decrease_nrof(object *op, uint32_t i)
Definition: object.c:2410
void play_sound_player_only(player *pl, int8_t sound_type, object *emitter, int dir, const char *action)
Definition: sounds.c:51
#define RANDOM()
Definition: define.h:681
int16_t grace
Definition: living.h:44
int cast_create_missile(object *op, object *caster, object *spell, int dir, const char *stringarg)
Definition: spell_effect.c:499
int mood_change(object *op, object *caster, object *spell)
Definition: spell_attack.c:904
tag_t count
Definition: object.h:299
living stats
Definition: object.h:370
#define FLAG_WIZCAST
Definition: define.h:290
#define SP_FAERY_FIRE
Definition: spells.h:118
struct archt * arch
Definition: object.h:415
int remove_curse(object *op, object *caster, object *spell)
int cast_earth_to_dust(object *op, object *caster, object *spell_ob)
Definition: spell_effect.c:865
#define SPELL_HIGHEST
Definition: spells.h:60
uint8_t type
Definition: object.h:340
struct Settings settings
Definition: init.c:39
void dump_spells(void)
Definition: spell_util.c:146
uint64_t spell_suppressions
Definition: global.h:354
struct archt * next
Definition: object.h:469
rangetype
Definition: player.h:15
int fire_bolt(object *op, object *caster, int dir, object *spob)
Definition: spell_attack.c:61
#define SP_MAGIC_MISSILE
Definition: spells.h:85
#define FLAG_APPLIED
Definition: define.h:235
void query_short_name(const object *op, char *buf, size_t size)
Definition: item.c:508
object * object_get_player_container(object *op)
Definition: object.c:377
#define SP_MAGIC_MAPPING
Definition: spells.h:88
signed int int32_t
Definition: win32.h:159
#define SP_LIGHT
Definition: spells.h:116
#define SP_SUMMON_MONSTER
Definition: spells.h:101
int16_t casting_time
Definition: object.h:405
#define FORCE_NAME
Definition: spells.h:169
#define AT_MAGIC
Definition: attack.h:77
int min_casting_level(const object *caster, const object *spell)
Definition: spell_util.c:203
int alchemy(object *op, object *caster, object *spell_ob)
#define GET_MAP_OB(M, X, Y)
Definition: map.h:172
#define FORCE_TRANSFORMED_ITEM
Definition: spells.h:146
#define FLAG_MONSTER
Definition: define.h:245
#define ARCH_SPELL_BLOCKED
Definition: object.h:582
int animate_weapon(object *op, object *caster, object *spell, int dir)
#define MSG_TYPE_SKILL
Definition: newclient.h:383
int get_map_flags(mapstruct *oldmap, mapstruct **newmap, int16_t x, int16_t y, int16_t *nx, int16_t *ny)
Definition: map.c:310
size_t split_string(char *str, char *array[], size_t array_size, char sep)
Definition: utils.c:500
struct obj * inv
Definition: object.h:290
#define NDI_UNIQUE
Definition: newclient.h:245
int get_cleric_chance(int stat)
Definition: living.c:2364
struct obj * head
Definition: object.h:296
void LOG(LogLevel logLevel, const char *format,...)
Definition: logger.c:51
#define SP_MAGIC_WALL
Definition: spells.h:89
int pets_summon_object(object *op, object *caster, object *spell_ob, int dir, const char *stringarg)
Definition: pets.c:908
#define FOR_MAP_PREPARE(map_, mx_, my_, it_)
Definition: define.h:760
void play_sound_map(int8_t sound_type, object *emitter, int dir, const char *action)
Definition: sounds.c:107
void check_spell_expiry(object *spell)
Definition: spell_util.c:2050
#define P_BLOCKSVIEW
Definition: map.h:226
int can_see_monsterP(mapstruct *m, int x, int y, int dir)
Definition: object.c:3601
int cast_change_map_lightlevel(object *op, object *caster, object *spell)
void query_name(const object *op, char *buf, size_t size)
Definition: item.c:583
#define SPELL_MANA
Definition: spells.h:58
#define SP_DISPEL_RUNE
Definition: spells.h:112
#define SP_ELEM_SHIELD
Definition: spells.h:124
#define MAX_SKILLS
Definition: skills.h:70
int cast_spell(object *op, object *caster, int dir, object *spell_ob, char *stringarg)
Definition: spell_util.c:1467
Definition: map.h:325
int random_roll(int min, int max, const object *op, int goodbad)
Definition: utils.c:42
const Face * face
Definition: object.h:333
static void prayer_failure(object *op, int failure, int power)
Definition: spell_util.c:1098
void spell_effect(object *spob, int x, int y, mapstruct *map, object *originator)
Definition: spell_util.c:183
int SP_level_wc_adjust(const object *caster, const object *spob)
Definition: spell_util.c:401
int SP_level_dam_adjust(const object *caster, const object *spob)
Definition: spell_util.c:326
int hit_player(object *op, int dam, object *hitter, uint32_t type, int full_hit)
Definition: attack.c:1867
int16_t level
Definition: object.h:353
uint8_t spell_failure_effects
Definition: global.h:270
void fix_object(object *op)
Definition: living.c:1120
#define SP_SUMMON_GOLEM
Definition: spells.h:86
#define SOUND_TYPE_SPELL
Definition: newclient.h:309
#define SP_PROBE
Definition: spells.h:94
#define SP_CREATE_FOOD
Definition: spells.h:96
EXTERN archetype * first_archetype
Definition: global.h:120
object * find_skill_by_name(object *who, const char *name)
Definition: skill_util.c:192
struct obj * more
Definition: object.h:295
object * arch_to_object(archetype *at)
Definition: arch.c:571
void object_update_speed(object *op)
Definition: object.c:1086
int cast_identify(object *op, object *caster, object *spell)
int32_t value
Definition: object.h:352
object * object_get_owner(object *op)
Definition: object.c:568
const char * name
Definition: object.h:468
int dispel_rune(object *op, object *caster, object *spell, object *skill, int dir)
Definition: rune.c:299
#define P_NO_CLERIC
Definition: map.h:238
#define SP_CONSECRATE
Definition: spells.h:114
int create_aura(object *op, object *caster, object *spell)
#define FOR_INV_PREPARE(op_, it_)
Definition: define.h:707
void object_remove(object *op)
Definition: object.c:1577
int cast_polymorph(object *op, object *caster, object *spell_ob, int dir)
Definition: spell_effect.c:431
int32_t food
Definition: living.h:48
int attacktype
Definition: attack.h:126
int magic_wall(object *op, object *caster, int dir, object *spell_ob)
#define PATH_SP_MULT(op, spell)
Definition: spells.h:36
#define SP_RAISE_DEAD
Definition: spells.h:75
#define SP_REMOVE_CURSE
Definition: spells.h:105