server/server/spell_effect.C

/*
 * CrossFire, A Multiplayer game for X-windows
 * 
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
 * Copyright (C) 1992 Frank Tore Johansen
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * The authors can be reached via e-mail at <crossfire@schmorp.de>
 */

#include <global.h>
#include <object.h>
#include <living.h>
#include <sproto.h>
#include <spells.h>
#include <sounds.h>

/* cast_magic_storm: This is really used mostly for spell
 * fumbles at the like.  tmp is the object to propogate.
 * op is what is casting this.
 */
void
cast_magic_storm (object *op, object *tmp, int lvl)
{
  if (!tmp)
    return;                     /* error */

  tmp->level = op->level;
  tmp->range += lvl / 5;        /* increase the area of destruction */
  tmp->duration += lvl / 5;

  /* Put a cap on duration for this - if the player fails in their
   * apartment, don't want it to go on so long that it kills them
   * multiple times.  Also, damge already increases with level,
   * so don't really need to increase the duration as much either.
   */
  if (tmp->duration >= 40)
    tmp->duration = 40;

  tmp->stats.dam = lvl;         /* nasty recoils! */
  tmp->stats.maxhp = tmp->count;        /* tract single parent */

  tmp->insert_at (op, op);
}

int
recharge (object *op, object *caster, object *spell_ob)
{
  object *wand, *tmp;
  int ncharges;

  wand = find_marked_object (op);
  if (wand == NULL || wand->type != WAND)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");
      return 0;
    }
  if (!(random_roll (0, 3, op, PREFER_HIGH)))
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
      play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);
      esrv_del_item (op->contr, wand->count);
      wand->destroy ();
      tmp = get_archetype ("fireball");
      tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;

      if (!tmp->stats.dam)
        tmp->stats.dam = 1;

      tmp->stats.hp = tmp->stats.dam / 2;

      if (tmp->stats.hp < 2)
        tmp->stats.hp = 2;

      tmp->insert_at (op);
      return 1;
    }

  ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));

  if (wand->inv && wand->inv->level)
    ncharges /= wand->inv->level;
  else
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));
      return 0;
    }

  if (!ncharges)
    ncharges = 1;

  wand->stats.food += ncharges;
  new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));

  if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))
    {
      SET_FLAG (wand, FLAG_ANIMATE);
      wand->set_speed (wand->arch->clone.speed);
    }

  return 1;
}

/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows
 * based on whether a crossbow or bow is equiped. If neither, it defaults to
 * arrows.
 * Sets the plus based on the casters level. It is also settable with the
 * invoke command. If the caster attempts to create missiles with too
 * great a plus, the default is used.
 * The # of arrows created also goes up with level, so if a 30th level mage
 * wants LOTS of arrows, and doesn't care what the plus is he could
 * create nonnmagic arrows, or even -1, etc...
 */

int
cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)
{
  int missile_plus = 0, bonus_plus = 0;
  const char *missile_name;
  object *tmp, *missile;

  missile_name = "arrow";

  for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
    if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
      missile_name = tmp->race;

  missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);

  if (archetype::find (missile_name) == NULL)
    {
      LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
      return 0;
    }

  missile = get_archetype (missile_name);

  if (stringarg)
    {
      /* If it starts with a letter, presume it is a description */
      if (isalpha (*stringarg))
        {
          artifact *al = find_artifactlist (missile->type)->items;

          for (; al != NULL; al = al->next)
            if (!strcasecmp (al->item->name, stringarg))
              break;

          if (!al)
            {
              missile->destroy ();
              new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg);
              return 0;
            }

          if (al->item->slaying)
            {
              missile->destroy ();
              new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);
              return 0;
            }

          give_artifact_abilities (missile, al->item);
          /* These special arrows cost something extra.  Don't have them also be magical -
           * otherwise, in most cases, not enough will be created.  I don't want to get into
           * the parsing of having to do both plus and type.
           */
          bonus_plus = 1 + (al->item->value / 5);
          missile_plus = 0;
        }
      else if (atoi (stringarg) < missile_plus)
        missile_plus = atoi (stringarg);
    }

  if (missile_plus > 4)
    missile_plus = 4;
  else if (missile_plus < -4)
    missile_plus = -4;

  missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
  missile->nrof -= 3 * (missile_plus + bonus_plus);

  if (missile->nrof < 1)
    missile->nrof = 1;

  missile->magic = missile_plus;
  /* Can't get any money for these objects */
  missile->value = 0;

  SET_FLAG (missile, FLAG_IDENTIFIED);

  if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())
    pick_up (op, missile);

  return 1;
}


/*  allows the choice of what sort of food object to make.
 *  If stringarg is NULL, it will create food dependent on level  --PeterM*/
int
cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg)
{
  int food_value;
  archetype *at = NULL;
  object *new_op;

  food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob);

  if (stringarg)
    {
      at = find_archetype_by_object_type_name (FOOD, stringarg);
      if (at == NULL)
        at = find_archetype_by_object_type_name (DRINK, stringarg);
      if (at == NULL || at->clone.stats.food > food_value)
        stringarg = NULL;
    }

  if (!stringarg)
    {
      archetype *at_tmp;

      /* We try to find the archetype with the maximum food value.
       * This removes the dependancy of hard coded food values in this
       * function, and addition of new food types is automatically added.
       * We don't use flesh types because the weight values of those need
       * to be altered from the donor.
       */

      /* We assume the food items don't have multiple parts */
      for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next)
        {
          if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK)
            {
              /* Basically, if the food value is something that is creatable
               * under the limits of the spell and it is higher than
               * the item we have now, take it instead.
               */
              if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food))
                at = at_tmp;
            }
        }
    }
  /* Pretty unlikely (there are some very low food items), but you never
   * know
   */
  if (!at)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
      return 0;
    }

  food_value /= at->clone.stats.food;
  new_op = arch_to_object (at);
  new_op->nrof = food_value;

  new_op->value = 0;
  if (new_op->nrof < 1)
    new_op->nrof = 1;

  cast_create_obj (op, caster, new_op, dir);
  return 1;
}

int
probe (object *op, object *caster, object *spell_ob, int dir)
{
  int r, mflags, maxrange;
  object *tmp;
  maptile *m;


  if (!dir)
    {
      examine_monster (op, op);
      return 1;
    }
  maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
  for (r = 1; r < maxrange; r++)
    {
      sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];

      m = op->map;
      mflags = get_map_flags (m, &m, x, y, &x, &y);

      if (mflags & P_OUT_OF_MAP)
        break;

      if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))
        {
          new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
          return 0;
        }
      if (mflags & P_IS_ALIVE)
        {
          for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
            if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
              {
                new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
                if (tmp->head != NULL)
                  tmp = tmp->head;
                examine_monster (op, tmp);
                return 1;
              }
        }
    }
  new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
  return 1;
}


/* This checks to see if 'pl' is invisible to 'mon'.
 * does race check, undead check, etc
 * Returns TRUE if mon can't see pl, false
 * otherwise.  This doesn't check range, walls, etc.  It
 * only checks the racial adjustments, and in fact that
 * pl is invisible.
 */
int
makes_invisible_to (object *pl, object *mon)
{

  if (!pl->invisible)
    return 0;
  if (pl->type == PLAYER)
    {
      /* If race isn't set, then invisible unless it is undead */
      if (!pl->contr->invis_race)
        {
          if (QUERY_FLAG (mon, FLAG_UNDEAD))
            return 0;
          return 1;
        }
      /* invis_race is set if we get here */
      if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))
        return 1;
      /* No race, can't be invisible to it */
      if (!mon->race)
        return 0;
      if (strstr (mon->race, pl->contr->invis_race))
        return 1;
      /* Nothing matched above, return 0 */
      return 0;
    }
  else
    {
      /* monsters are invisible to everything */
      return 1;
    }
}

/* Makes the player or character invisible.
 * Note the spells to 'stack', but perhaps in odd ways.
 * the duration for all is cumulative.
 * In terms of invis undead/normal invis, it is the last one cast that
 * will determine if you are invisible to undead or normal monsters.
 * For improved invis, if you cast it with a one of the others, you
 * lose the improved part of it, and the above statement about undead/
 * normal applies.
 */
int
cast_invisible (object *op, object *caster, object *spell_ob)
{
  if (op->invisible > 1000)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
      return 0;
    }

  /* Remove the switch with 90% duplicate code - just handle the differences with
   * and if statement or two.
   */
  op->invisible += spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
  /* max duration */
  if (op->invisible > 1000)
    op->invisible = 1000;

  if (op->type == PLAYER)
    {
      op->contr->invis_race = spell_ob->race;

      if (QUERY_FLAG (spell_ob, FLAG_MAKE_INVIS))
        op->contr->tmp_invis = 0;
      else
        op->contr->tmp_invis = 1;

      op->contr->hidden = 0;
    }

  if (makes_invisible_to (op, op))
    new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
  else
    new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");

  update_object (op, UP_OBJ_CHANGE);

  /* Only search the active objects - only these should actually do
   * harm to the player.
   */
  for_all_actives (tmp)
    if (tmp->enemy == op)
      tmp->enemy = 0;

  return 1;
}

/* earth to dust spell.  Basically destroys earthwalls in the area.
 */
int
cast_earth_to_dust (object *op, object *caster, object *spell_ob)
{
  object *tmp, *next;
  int range, i, j, mflags;
  sint16 sx, sy;
  maptile *m;

  if (op->type != PLAYER)
    return 0;

  range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);

  for (i = -range; i <= range; i++)
    for (j = -range; j <= range; j++)
      {
        sx = op->x + i;
        sy = op->y + j;
        m = op->map;
        mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);

        if (mflags & P_OUT_OF_MAP)
          continue;

        // earth to dust tears down everything that can be teared down
        for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
          {
            next = tmp->above;
            if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
              hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
          }
      }

  return 1;
}

void
execute_word_of_recall (object *op)
{
  if (object *pl = op->in_player ())
    {
      if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
        new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
      else
        {
          // remove first so we do not call update_stats
          op->remove ();
          pl->enter_exit (op);
        }
    }

  op->destroy ();
}

/* Word of recall causes the player to return 'home'.
 * we put a force into the player object, so that there is a 
 * time delay effect.
 */
int
cast_word_of_recall (object *op, object *caster, object *spell_ob)
{
  object *dummy;
  int time;

  if (op->type != PLAYER)
    return 0;

  if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL))
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
      return 1;
    }

  dummy = get_archetype (FORCE_NAME);
  if (dummy == NULL)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
      LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
      return 0;
    }

  time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
  if (time < 1)
    time = 1;

  /* value of speed really doesn't make much difference, as long as it is
   * positive.  Lower value may be useful so that the problem doesn't
   * do anything really odd if it say a -1000 or something.
   */
  dummy->set_speed (0.002);
  dummy->speed_left = -dummy->speed * time;
  dummy->type = SPELL_EFFECT;
  dummy->subtype = SP_WORD_OF_RECALL;

  /* If we could take advantage of enter_player_savebed() here, it would be
   * nice, but until the map load fails, we can't.
   */
  EXIT_PATH (dummy) = op->contr->savebed_map;
  EXIT_X    (dummy) = op->contr->bed_x;
  EXIT_Y    (dummy) = op->contr->bed_y;

  op->insert (dummy);

  new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");

  return 1;
}

/* cast_wonder
 * wonder is really just a spell that will likely cast another
 * spell.
 */
int
cast_wonder (object *op, object *caster, int dir, object *spell_ob)
{
  object *newspell;

  if (!rndm (0, 3))
    return cast_cone (op, caster, dir, spell_ob);

  if (spell_ob->randomitems)
    {
      newspell = generate_treasure (spell_ob->randomitems, caster->level);
      if (!newspell)
        {
          LOG (llevError, "cast_wonder: Unable to get a spell!\n");
          return 0;
        }
      if (newspell->type != SPELL)
        {
          LOG (llevError, "cast_wonder: spell returned is not a spell (%d, %s)!\n", &newspell->type, &newspell->name);
          return 0;
        }
      /* Prevent inifinit recursion */
      if (newspell->subtype == SP_WONDER)
        {
          LOG (llevError, "cast_wonder: spell returned is another wonder spell!\n");
          return 0;
        }
      return cast_spell (op, caster, dir, newspell, NULL);
    }
  return 1;
}

int
perceive_self (object *op)
{
  char *cp = describe_item (op, op), buf[MAX_BUF];
  archetype *at = archetype::find (ARCH_DEPLETION);
  object *tmp;
  int i;

  tmp = find_god (determine_god (op));
  if (tmp)
    new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
  else
    new_draw_info (NDI_UNIQUE, 0, op, "You worship no god");

  tmp = present_arch_in_ob (at, op);

  if (*cp == '\0' && tmp == NULL)
    new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");
  else
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You have:");
      new_draw_info (NDI_UNIQUE, 0, op, cp);
      if (tmp != NULL)
        {
          for (i = 0; i < NUM_STATS; i++)
            {
              if (get_attr_value (&tmp->stats, i) < 0)
                {
                  new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
                }
            }
        }
    }

  if (is_dragon_pl (op))
    {
      /* now grab the 'dragon_ability'-force from the player's inventory */
      for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
        {
          if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))
            {
              if (tmp->stats.exp == 0)
                sprintf (buf, "Your metabolism isn't focused on anything.");
              else
                sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);

              new_draw_info (NDI_UNIQUE, 0, op, buf);
              break;
            }
        }
    }

  return 1;
}

/* int cast_create_town_portal (object *op, object *caster, int dir)
 *
 * This function cast the spell of town portal for op
 *
 * The spell operates in two passes. During the first one a place
 * is marked as a destination for the portal. During the second one,
 * 2 portals are created, one in the position the player cast it and
 * one in the destination place. The portal are synchronized and 2 forces
 * are inserted in the player to destruct the portal next time player
 * creates a new portal pair.
 * This spell has a side effect that it allows people to meet each other
 * in a permanent, private,  appartements by making a town portal from it
 * to the town or another public place. So, check if the map is unique and if
 * so return an error
 *
 * Code by Tchize (david.delbecq@usa.net)
 */
int
cast_create_town_portal (object *op, object *caster, object *spell, int dir)
{
  object *dummy, *force, *old_force;
  archetype *perm_portal;
  char portal_name[1024], portal_message[1024];
  maptile *exitmap;
  int op_level;

  /* Check to see if the map the player is currently on is a per player unique
   * map.  This can be determined in that per player unique maps have the
   * full pathname listed.
   */
  if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
    {
      new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
      return 0;
    }

  /* The first thing to do is to check if we have a marked destination
   * dummy is used to make a check inventory for the force
   */
  dummy = arch_to_object (spell->other_arch);
  if (dummy == NULL)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
      LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
      return 0;
    }

  force = check_inv_recursive (op, dummy);

  if (force == NULL)
    {
      /* Here we know there is no destination marked up.
       * We have 2 things to do:
       * 1. Mark the destination in the player inventory.
       * 2. Let the player know it worked.
       */
      dummy->name = op->map->path;
      EXIT_X (dummy) = op->x;
      EXIT_Y (dummy) = op->y;
      insert_ob_in_ob (dummy, op);
      new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You fix this place in your mind.\nYou feel you are able to come here from anywhere.");
      return 1;
    }

  dummy->destroy ();

  /* Here we know where the town portal should go to
   * We should kill any existing portal associated with the player.
   * Than we should create the 2 portals.
   * For each of them, we need:
   *    - To create the portal with the name of the player+destination map
   *    - set the owner of the town portal
   *    - To mark the position of the portal in the player's inventory
   *      for easier destruction. 
   *
   *  The mark works has follow:
   *   slaying: Existing town portal
   *   hp, sp : x & y of the associated portal
   *   name   : name of the portal
   *   race   : map the portal is in
   */

  /* First step: killing existing town portals */
  dummy = get_archetype (spell->race);
  if (dummy == NULL)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
      LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
      return 0;
    }

  perm_portal = archetype::find (spell->slaying);

  /* To kill a town portal, we go trough the player's inventory,
   * for each marked portal in player's inventory,
   *   -We try load the associated map (if impossible, consider the portal destructed)
   *   -We find any portal in the specified location.
   *      If it has the good name, we destruct it.
   *   -We destruct the force indicating that portal.
   */
  while ((old_force = check_inv_recursive (op, dummy)))
    {
      exitmap = maptile::find_sync (old_force->race, op->map);

      if (exitmap)
        {
          exitmap->load_sync ();

          int exitx = EXIT_X (old_force);
          int exity = EXIT_Y (old_force);

          for (object *tmp = present_arch (perm_portal, exitmap, exitx, exity); tmp; tmp = tmp->above)
            {
              if (tmp->name == old_force->name)
                {
                  tmp->destroy ();
                  break;
                }
            }
        }

      old_force->destroy ();
    }

  dummy->destroy ();

  /* Creating the portals.
   * The very first thing to do is to ensure
   * access to the destination map.
   * If we can't, don't fizzle. Simply warn player.
   * This ensure player pays his mana for the spell
   * because HE is responsible of forgotting.
   * 'force' is the destination of the town portal, which we got
   * from the players inventory above.
   */

  /* Ensure exit map is loaded */
  exitmap = maptile::find_sync (force->name);

  /* If we were unable to load (ex. random map deleted), warn player */
  if (!exitmap)
    {
      new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
      force->destroy ();
      return 1;
    }

  exitmap->load_sync ();

  op_level = caster_level (caster, spell);
  if (op_level < 15)
    snprintf (portal_message, 1024,
              "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
              &op->name);
  else if (op_level < 30)
    snprintf (portal_message, 1024,
              "\n%s's portal smells of ozone.\nYou do a lot of movements and finally pass\nthrough the small hole in the air\n", &op->name);
  else if (op_level < 60)
    snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
  else
    snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
              &op->name);

  /* Create a portal in front of player
   * dummy contain the portal and
   * force contain the track to kill it later
   */
  snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
  dummy = get_archetype (spell->slaying);       /*The portal */
  if (dummy == NULL)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
      LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
      return 0;
    }

  EXIT_PATH (dummy) = force->name;
  EXIT_X (dummy) = EXIT_X (force);
  EXIT_Y (dummy) = EXIT_Y (force);
  dummy->name = dummy->name_pl = portal_name;
  dummy->msg = portal_message;
  dummy->race = op->name;       /*Save the owner of the portal */
  cast_create_obj (op, caster, dummy, 0);

  /* Now we need to to create a town portal marker inside the player
   * object, so on future castings, we can know that he has an active
   * town portal.
   */
  object *tmp = get_archetype (spell->race);

  if (!tmp)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
      LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
      return 0;
    }

  tmp->race = op->map->path;
  tmp->name = portal_name;
  EXIT_X (tmp) = dummy->x;
  EXIT_Y (tmp) = dummy->y;
  op->insert (tmp);

  /* Create a portal in the destination map
   * dummy contain the portal and
   * force the track to kill it later
   * the 'force' variable still contains the 'reminder' of
   * where this portal goes to.
   */
  snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &op->map->path);
  dummy = get_archetype (spell->slaying);       /*The portal */
  if (dummy == NULL)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
      LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
      return 0;
    }

  EXIT_PATH (dummy) = op->map->path;
  EXIT_X (dummy) = op->x;
  EXIT_Y (dummy) = op->y;
  dummy->name = dummy->name_pl = portal_name;
  dummy->msg = portal_message;
  dummy->race = op->name;       /*Save the owner of the portal */
  exitmap->insert (dummy, EXIT_X (force), EXIT_Y (force), op);

  /* Now we create another town portal marker that
   * points back to the one we just made
   */
  tmp = get_archetype (spell->race);
  if (tmp == NULL)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
      LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
      return 0;
    }

  tmp->race = force->name;
  tmp->name = portal_name;
  EXIT_X (tmp) = dummy->x;
  EXIT_Y (tmp) = dummy->y;
  insert_ob_in_ob (tmp, op);

  /* Describe the player what happened
   */
  new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
  force->destroy ();

  return 1;
}

/* This creates magic walls.  Really, it can create most any object,
 * within some reason.
 */
int
magic_wall (object *op, object *caster, int dir, object *spell_ob)
{
  object *tmp;
  int i, posblocked, negblocked, maxrange;
  sint16 x, y;
  maptile *m;
  const char *name;
  archetype *at;

  if (!dir)
    {
      dir = op->facing;
      x = op->x;
      y = op->y;
    }
  else
    {
      x = op->x + freearr_x[dir];
      y = op->y + freearr_y[dir];
    }

  m = op->map;

  if ((spell_ob->move_block || x != op->x || y != op->y) &&
      (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
       ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
      return 0;
    }

  if (spell_ob->other_arch)
    tmp = arch_to_object (spell_ob->other_arch);
  else if (spell_ob->race)
    {
      char buf1[MAX_BUF];

      sprintf (buf1, spell_ob->race, dir);
      at = archetype::find (buf1);
      if (!at)
        {
          LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
          new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
          return 0;
        }

      tmp = arch_to_object (at);
    }
  else
    {
      LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
      return 0;
    }

  if (tmp->type == SPELL_EFFECT)
    {
      tmp->attacktype = spell_ob->attacktype;
      tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
      tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
      tmp->range = 0;
    }
  else if (QUERY_FLAG (tmp, FLAG_ALIVE))
    {
      tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
      tmp->stats.maxhp = tmp->stats.hp;
    }

  if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP))
    {
      tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
      SET_FLAG (tmp, FLAG_IS_USED_UP);
    }

  if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))
    {
      tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
      tmp->stats.maxhp = tmp->stats.hp;
      SET_FLAG (tmp, FLAG_TEAR_DOWN);
      SET_FLAG (tmp, FLAG_ALIVE);
    }

  /* This can't really hurt - if the object doesn't kill anything,
   * these fields just won't be used. Do not set the owner for
   * earthwalls, though, so they survive restarts.
   */
  if (tmp->type != EARTHWALL) //TODO
    tmp->set_owner (op);

  set_spell_skill (op, caster, spell_ob, tmp);
  tmp->level = caster_level (caster, spell_ob) / 2;

  name = tmp->name;
  if (!(tmp = m->insert (tmp, x, y, op)))
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
      return 0;
    }

  /* If this is a spellcasting wall, need to insert the spell object */
  if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)
    insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);

  /*  This code causes the wall to extend some distance in
   * each direction, or until an obstruction is encountered. 
   * posblocked and negblocked help determine how far the
   * created wall can extend, it won't go extend through
   * blocked spaces.
   */
  maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
  posblocked = 0;
  negblocked = 0;

  for (i = 1; i <= maxrange; i++)
    {
      int dir2;

      dir2 = (dir < 4) ? (dir + 2) : dir - 2;

      x = tmp->x + i * freearr_x[dir2];
      y = tmp->y + i * freearr_y[dir2];
      m = tmp->map;

      if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
          ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
        {
          object *tmp2 = tmp->clone ();
          m->insert (tmp2, x, y, op);

          /* If this is a spellcasting wall, need to insert the spell object */
          if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
            tmp2->insert (arch_to_object (tmp2->other_arch));

        }
      else
        posblocked = 1;

      x = tmp->x - i * freearr_x[dir2];
      y = tmp->y - i * freearr_y[dir2];
      m = tmp->map;

      if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
          ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
        {
          object *tmp2 = tmp->clone ();
          m->insert (tmp2, x, y, op);

          if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
            tmp2->insert (arch_to_object (tmp2->other_arch));
        }
      else
        negblocked = 1;
    }

  if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW))
    update_all_los (op->map, op->x, op->y);

  return 1;
}

int
dimension_door (object *op, object *caster, object *spob, int dir)
{
  uint32 dist, maxdist;
  int mflags;
  maptile *m;
  sint16 sx, sy;

  if (op->type != PLAYER)
    return 0;

  if (!dir)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");
      return 0;
    }

  /* Given the new outdoor maps, can't let players dimension door for
   * ever, so put limits in.
   */
  maxdist = spob->range + SP_level_range_adjust (caster, spob);

  if (op->contr->count)
    {
      if (op->contr->count > maxdist)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");
          return 0;
        }

      for (dist = 0; dist < op->contr->count; dist++)
        {
          mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);

          if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
            break;

          if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
            break;
        }

      if (dist < op->contr->count)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
          op->contr->count = 0;
          return 0;
        }

      op->contr->count = 0;

      /* Remove code that puts player on random space on maps.  IMO,
       * a lot of maps probably have areas the player should not get to,
       * but may not be marked as NO_MAGIC (as they may be bounded
       * by such squares).  Also, there are probably treasure rooms and
       * lots of other maps that protect areas with no magic, but the
       * areas themselves don't contain no magic spaces.
       */
      /* This call here is really just to normalize the coordinates */
      mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, &sx, &sy);
      if (mflags & P_IS_ALIVE || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
        {
          new_draw_info (NDI_UNIQUE, 0, op, "You cast your spell, but nothing happens.\n");
          return 1;             /* Maybe the penalty should be more severe... */
        }
    }
  else
    {
      /* Player didn't specify a distance, so lets see how far
       * we can move the player.  Don't know why this stopped on
       * spaces that blocked the players view.
       */

      for (dist = 0; dist < maxdist; dist++)
        {
          mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);

          if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
            break;

          if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
            break;

        }

      /* If the destination is blocked, keep backing up until we
       * find a place for the player.
       */
      for (; dist > 0; dist--)
        {
          if (get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist,
                             &sx, &sy) & (P_OUT_OF_MAP | P_IS_ALIVE))
            continue;


          if (!OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
            break;

        }
      if (!dist)
        {
          new_draw_info (NDI_UNIQUE, 0, op, "Your spell failed!\n");
          return 0;
        }
    }

  /* Actually move the player now */
  if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
    return 1;

  op->speed_left = -FABS (op->speed) * 5;       /* Freeze them for a short while */
  return 1;
}


/* cast_heal: Heals something.
 * op is the caster.
 * dir is the direction he is casting it in.
 * spell is the spell object.
 */
int
cast_heal (object *op, object *caster, object *spell, int dir)
{
  object *tmp;
  archetype *at;
  object *poison;
  int heal = 0, success = 0;

  tmp = find_target_for_friendly_spell (op, dir);

  if (!tmp)
    return 0;

  /* Figure out how many hp this spell might cure.
   * could be zero if this spell heals effects, not damage.
   */
  heal = spell->stats.dam;
  if (spell->stats.hp)
    heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;

  if (heal)
    {
      if (tmp->stats.hp >= tmp->stats.maxhp)
        new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
      else
        {
          /* See how many points we actually heal.  Instead of messages
           * based on type of spell, we instead do messages based
           * on amount of damage healed.
           */
          if (heal > (tmp->stats.maxhp - tmp->stats.hp))
            heal = tmp->stats.maxhp - tmp->stats.hp;
          tmp->stats.hp += heal;

          if (tmp->stats.hp >= tmp->stats.maxhp)
            new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
          else if (heal > 50)
            new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
          else if (heal > 25)
            new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
          else if (heal > 10)
            new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
          else
            new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");

          success = 1;
        }
    }

  if (spell->attacktype & AT_DISEASE)
    if (cure_disease (tmp, op))
      success = 1;

  if (spell->attacktype & AT_POISON)
    {
      at = archetype::find ("poisoning");
      poison = present_arch_in_ob (at, tmp);
      if (poison)
        {
          success = 1;
          new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
          poison->stats.food = 1;
        }
    }

  if (spell->attacktype & AT_CONFUSION)
    {
      poison = present_in_ob_by_name (FORCE, "confusion", tmp);
      if (poison)
        {
          success = 1;
          new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
          poison->duration = 1;
        }
    }

  if (spell->attacktype & AT_BLIND)
    {
      at = archetype::find ("blindness");
      poison = present_arch_in_ob (at, tmp);
      if (poison)
        {
          success = 1;
          new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
          poison->stats.food = 1;
        }
    }

  if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
    {
      tmp->stats.sp += spell->last_sp;
      if (tmp->stats.sp > tmp->stats.maxsp)
        tmp->stats.sp = tmp->stats.maxsp;
      success = 1;
      new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
    }

  if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
    {
      tmp->stats.grace += spell->last_grace;
      if (tmp->stats.grace > tmp->stats.maxgrace)
        tmp->stats.grace = tmp->stats.maxgrace;
      success = 1;
      new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
    }

  if (spell->stats.food && tmp->stats.food < 999)
    {
      tmp->stats.food += spell->stats.food;
      if (tmp->stats.food > 999)
        tmp->stats.food = 999;
      success = 1;
      /* We could do something a bit better like the messages for healing above */
      new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
    }

  return success;
}


/* This is used for the spells that gain stats.  There are no spells
 * right now that icnrease wis/int/pow on a temp basis, so no
 * good comments for those.
 */
static const char *const no_gain_msgs[NUM_STATS] = {
  "You grow no stronger.",
  "You grow no more agile.",
  "You don't feel any healthier.",
  "no wis",
  "You are no easier to look at.",
  "no int",
  "no pow"
};

int
cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
{
  object *force = NULL;
  int i;

  /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
  object *tmp = dir
     ? find_target_for_friendly_spell (op, dir)
     : op;

  if (!tmp)
    return 0;

  /* If we've already got a force of this type, don't add a new one. */
  for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
    {
      if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
        {
          if (tmp2->name == spell_ob->name)
            {
              force = tmp2;     /* the old effect will be "refreshed" */
              break;
            }
          else if (spell_ob->race && spell_ob->race == tmp2->name)
            {
              if (!silent)
                new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
              return 0;
            }
        }
    }
  if (force == NULL)
    {
      force = get_archetype (FORCE_NAME);
      force->subtype = FORCE_CHANGE_ABILITY;
      if (spell_ob->race)
        force->name = spell_ob->race;
      else
        force->name = spell_ob->name;
      force->name_pl = spell_ob->name;
      new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");

    }
  else
    {
      int duration;

      duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
      if (duration > force->duration)
        {
          force->duration = duration;
          new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
        }
      else
        {
          new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
        }
      return 1;
    }
  force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
  force->speed = 1.0;
  force->speed_left = -1.0;
  SET_FLAG (force, FLAG_APPLIED);

  /* Now start processing the effects.  First, protections */
  for (i = 0; i < NROFATTACKS; i++)
    {
      if (spell_ob->resist[i])
        {
          force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
          if (force->resist[i] > 100)
            force->resist[i] = 100;
        }
    }
  if (spell_ob->stats.hp)
    force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);

  if (tmp->type == PLAYER)
    {
      /* Stat adjustment spells */
      for (i = 0; i < NUM_STATS; i++)
        {
          sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm;

          if (stat)
            {
              sm = 0;
              for (k = 0; k < stat; k++)
                sm += rndm (1, 3);

              if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat))
                {
                  sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i);
                  if (sm < 0)
                    sm = 0;
                }
              set_attr_value (&force->stats, i, sm);
              if (!sm)
                new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
            }
        }
    }

  force->move_type = spell_ob->move_type;

  if (QUERY_FLAG (spell_ob, FLAG_SEE_IN_DARK))
    SET_FLAG (force, FLAG_SEE_IN_DARK);

  if (QUERY_FLAG (spell_ob, FLAG_XRAYS))
    SET_FLAG (force, FLAG_XRAYS);

  /* Haste/bonus speed */
  if (spell_ob->stats.exp)
    {
      if (op->speed > 0.5f)
        force->stats.exp = (sint64) ((float) spell_ob->stats.exp / (op->speed + 0.5f));
      else
        force->stats.exp = spell_ob->stats.exp;
    }

  force->stats.wc = spell_ob->stats.wc;
  force->stats.ac = spell_ob->stats.ac;
  force->attacktype = spell_ob->attacktype;

  insert_ob_in_ob (force, tmp);
  change_abil (tmp, force);     /* Mostly to display any messages */
  tmp->update_stats ();
  return 1;
}

/* This used to be part of cast_change_ability, but it really didn't make
 * a lot of sense, since most of the values it derives are from the god
 * of the caster.
 */

int
cast_bless (object *op, object *caster, object *spell_ob, int dir)
{
  int i;
  object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;

  /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
  if (dir != 0)
    {
      tmp = find_target_for_friendly_spell (op, dir);
    }
  else
    {
      tmp = op;
    }

  /* If we've already got a force of this type, don't add a new one. */
  for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)
    {
      if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
        {
          if (tmp2->name == spell_ob->name)
            {
              force = tmp2;     /* the old effect will be "refreshed" */
              break;
            }
          else if (spell_ob->race && spell_ob->race == tmp2->name)
            {
              new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
              return 0;
            }
        }
    }
  if (force == NULL)
    {
      force = get_archetype (FORCE_NAME);
      force->subtype = FORCE_CHANGE_ABILITY;
      if (spell_ob->race)
        force->name = spell_ob->race;
      else
        force->name = spell_ob->name;
      force->name_pl = spell_ob->name;
      new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
    }
  else
    {
      int duration;

      duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
      if (duration > force->duration)
        {
          force->duration = duration;
          new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
        }
      else
        {
          new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
        }
      return 0;
    }
  force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
  force->speed = 1.0;
  force->speed_left = -1.0;
  SET_FLAG (force, FLAG_APPLIED);

  if (!god)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");
    }
  else
    {
      /* Only give out good benefits, and put a max on it */
      for (i = 0; i < NROFATTACKS; i++)
        {
          if (god->resist[i] > 0)
            {
              force->resist[i] = MIN (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);
            }
        }
      force->path_attuned |= god->path_attuned;

      if (spell_ob->attacktype)
        force->slaying = god->slaying;

      if (tmp != op)
        {
          new_draw_info_format (NDI_UNIQUE, 0, op, "You bless %s.", &tmp->name);
          new_draw_info_format (NDI_UNIQUE, 0, tmp, "%s blessed you.", &op->name);
        }
      else
        {
          new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are blessed by %s!", &god->name);
        }

    }
  force->stats.wc = spell_ob->stats.wc;
  force->stats.ac = spell_ob->stats.ac;

  change_abil (tmp, force);     /* Mostly to display any messages */
  insert_ob_in_ob (force, tmp);
  tmp->update_stats ();
  return 1;
}

/* Alchemy code by Mark Wedel
 *
 * This code adds a new spell, called alchemy.  Alchemy will turn
 * objects to gold nuggets, the value of the gold nuggets being
 * about 90% of that of the item itself.  It uses the value of the
 * object before charisma adjustments, because the nuggets themselves
 * will be will be adjusted by charisma when sold.
 *
 * Large nuggets are worth 25 gp each (base).  You will always get
 * the maximum number of large nuggets you could get.
 * Small nuggets are worth 1 gp each (base).  You will get from 0
 * to the max amount of small nuggets as you could get.
 *
 * For example, if an item is worth 110 gold, you will get
 * 4 large nuggets, and from 0-10 small nuggets.
 *
 * There is also a chance (1:30) that you will get nothing at all
 * for the object.  There is also a maximum weight that will be
 * alchemised.
 */
static void
alchemy_object (object *obj, uint64 &total_value, int &total_weight)
{
  uint64 value = query_cost (obj, NULL, F_TRUE);

  /* Give third price when we alchemy money (This should hopefully
   * make it so that it isn't worth it to alchemy money, sell
   * the nuggets, alchemy the gold from that, etc.
   * Otherwise, give 9 silver on the gold for other objects,
   * so that it would still be more affordable to haul
   * the stuff back to town.
   */
  if (QUERY_FLAG (obj, FLAG_UNPAID))
    value = 0;
  else if (obj->type == MONEY || obj->type == GEM)
    value /= 3;
  else
    value = value * 9 / 10;

  if (obj->value > 0 && rndm (0, 29))
    total_value += value;

  total_weight += obj->total_weight ();

  obj->destroy ();
}

static void
update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
{
  int flag = 0;

  /* Put any nuggets below the player, but we can only pass this
   * flag if we are on the same space as the player 
   */
  if (x == op->x && y == op->y && op->map == m)
    flag = INS_BELOW_ORIGINATOR;

  if (small_nuggets)
    {
      object *tmp = small->clone ();
      tmp->nrof = small_nuggets;
      m->insert (tmp, x, y, op, flag);
    }

  if (large_nuggets)
    {
      object *tmp = large->clone ();
      tmp->nrof = large_nuggets;
      m->insert (tmp, x, y, op, flag);
    }

  if (object *pl = m->at (x, y).player ())
    if (pl->contr->ns)
      pl->contr->ns->look_position = 0;
}

int
alchemy (object *op, object *caster, object *spell_ob)
{
  if (op->type != PLAYER)
    return 0;

  object *large = get_archetype ("largenugget");
  object *small = get_archetype ("smallnugget");

  /* Put a maximum weight of items that can be alchemised. Limits the power
   * some, and also prevents people from alchemising every table/chair/clock
   * in sight
   */
  int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
  int weight_max   = duration * 1000;
  uint64 value_max = duration * 1000;

  int weight = 0;

  for (int y = op->y - 1; y <= op->y + 1; y++)
    {
      for (int x = op->x - 1; x <= op->x + 1; x++)
        {
          uint64 value = 0;

          sint16 nx = x;
          sint16 ny = y;

          maptile *mp = op->map;

          int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);

          if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
            continue;

          /* Treat alchemy a little differently - most spell effects
           * use fly as the movement type - for alchemy, consider it
           * ground level effect.
           */
          if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
            continue;

          for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
            {
              next = tmp->above;

              if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
                  !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
                {
                  if (tmp->inv)
                    {
                      object *next1, *tmp1;

                      for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
                        {
                          next1 = tmp1->below;
                          if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
                              !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
                            alchemy_object (tmp1, value, weight);
                        }
                    }

                  alchemy_object (tmp, value, weight);

                  if (weight > weight_max)
                    break;
                }
            }

          value = min (value, value_max);

          uint64 count = value / large->value;
          int large_nuggets = count;
          value -= count * large->value;

          count = value / small->value;
          int small_nuggets = count;

          /* Insert all the nuggets at one time.  This probably saves time, but
           * it also prevents us from alcheming nuggets that were just created
           * with this spell.
           */
          update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);

          if (weight > weight_max)
            goto bailout;
        }
    }

bailout:
  large->destroy ();
  small->destroy ();
  return 1;
}


/* This function removes the cursed/damned status on equipped
 * items.
 */
int
remove_curse (object *op, object *caster, object *spell)
{
  object *tmp;
  int success = 0, was_one = 0;

  for (tmp = op->inv; tmp; tmp = tmp->below)
    if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
        ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
         (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
      {
        was_one++;
        if (tmp->level <= caster_level (caster, spell))
          {
            success++;
            if (QUERY_FLAG (spell, FLAG_DAMNED))
              CLEAR_FLAG (tmp, FLAG_DAMNED);

            CLEAR_FLAG (tmp, FLAG_CURSED);
            CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
            tmp->value = 0;     /* Still can't sell it */
            if (op->type == PLAYER)
              esrv_send_item (op, tmp);
          }
      }

  if (op->type == PLAYER)
    {
      if (success)
        new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
      else
        {
          if (was_one)
            new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
          else
            new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items.");
        }
    }

  return success;
}

/* Identifies objects in the players inventory/on the ground */

int
cast_identify (object *op, object *caster, object *spell)
{
  object *tmp;
  int success = 0, num_ident;

  num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);

  if (num_ident < 1)
    num_ident = 1;

  for (tmp = op->inv; tmp; tmp = tmp->below)
    {
      if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
        {
          identify (tmp);

          if (op->type == PLAYER)
            {
              new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op));

              if (tmp->msg)
                {
                  new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
                  new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
                }
            }

          num_ident--;
          success = 1;
          if (!num_ident)
            break;
        }
    }

  /* If all the power of the spell has been used up, don't go and identify
   * stuff on the floor.  Only identify stuff on the floor if the spell
   * was not fully used.
   */
  if (num_ident)
    {
      for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
        if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
          {
            identify (tmp);

            if (op->type == PLAYER)
              {
                new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));

                if (tmp->msg)
                  {
                    new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
                    new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
                  }

                esrv_send_item (op, tmp);
              }

            num_ident--;
            success = 1;
            if (!num_ident)
              break;
          }
    }

  if (!success)
    new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");
  else
    spell_effect (spell, op->x, op->y, op->map, op);

  return success;
}

int
cast_detection (object *op, object *caster, object *spell, object *skill)
{
  object *tmp, *last, *god, *detect;
  int done_one, range, mflags, floor, level;
  sint16 x, y, nx, ny;
  maptile *m;

  /* We precompute some values here so that we don't have to keep
   * doing it over and over again.
   */
  god = find_god (determine_god (op));
  level = caster_level (caster, spell);
  range = spell->range + SP_level_range_adjust (caster, spell);

  if (!skill)
    skill = caster;

  for (x = op->x - range; x <= op->x + range; x++)
    for (y = op->y - range; y <= op->y + range; y++)
      {
        m = op->map;
        mflags = get_map_flags (m, &m, x, y, &nx, &ny);
        if (mflags & P_OUT_OF_MAP)
          continue;

        /* For most of the detections, we only detect objects above the
         * floor.  But this is not true for show invisible.
         * Basically, we just go and find the top object and work
         * down - that is easier than working up.
         */

        for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)
          last = tmp;

        /* Shouldn't happen, but if there are no objects on a space, this
         * would happen.
         */
        if (!last)
          continue;

        done_one = 0;
        floor = 0;
        detect = NULL;
        for (tmp = last; tmp; tmp = tmp->below)
          {
            /* show invisible */
            if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
                /* Might there be other objects that we can make visible? */
                (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||
                                    (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||
                                    tmp->type == CF_HANDLE ||
                                    tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||
                                    tmp->type == BUTTON || tmp->type == TELEPORTER ||
                                    tmp->type == GATE || tmp->type == LOCKED_DOOR ||
                                    tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN ||
                                    tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY ||
                                    tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR)))
              {
                if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
                  {
                    tmp->invisible = 0;
                    done_one = 1;
                  }
              }

            if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
              floor = 1;

            /* All detections below this point don't descend beneath the floor,
             * so just continue on.  We could be clever and look at the type of
             * detection to completely break out if we don't care about objects beneath
             * the floor, but once we get to the floor, not likely a very big issue anyways.
             */
            if (floor)
              continue;

            /* I had thought about making detect magic and detect curse
             * show the flash the magic item like it does for detect monster.
             * however, if the object is within sight, this would then make it
             * difficult to see what object is magical/cursed, so the
             * effect wouldn't be as apparant.
             */

            /* detect magic */
            if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
                !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
              {
                SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
                /* make runes more visibile */
                if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
                  tmp->stats.Cha /= 4;
                done_one = 1;
              }
            /* detect monster */
            if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
              {
                done_one = 2;
                if (!detect)
                  detect = tmp;
              }
            /* Basically, if race is set in the spell, then the creatures race must
             * match that.  if the spell race is set to GOD, then the gods opposing
             * race must match.
             */
            if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
                ((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||
                 (strstr (spell->race, tmp->race))))
              {
                done_one = 2;
                if (!detect)
                  detect = tmp;
              }
            if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
                (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
              {
                SET_FLAG (tmp, FLAG_KNOWN_CURSED);
                done_one = 1;
              }
          }                     /* for stack of objects on this space */

        /* Code here puts an effect of the spell on the space, so you can see
         * where the magic is.
         */
        if (done_one)
          {
            object *detect_ob = arch_to_object (spell->other_arch);

            /* if this is set, we want to copy the face */
            if (done_one == 2 && detect)
              {
                detect_ob->face = detect->face;
                detect_ob->animation_id = detect->animation_id;
                detect_ob->anim_speed = detect->anim_speed;
                detect_ob->last_anim = 0;
                /* by default, the detect_ob is already animated */
                if (!QUERY_FLAG (detect, FLAG_ANIMATE))
                  CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
              }

            m->insert (detect_ob, nx, ny, op);
          }
      }                         /* for processing the surrounding spaces */


  /* Now process objects in the players inventory if detect curse or magic */
  if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
    {
      done_one = 0;
      for (tmp = op->inv; tmp; tmp = tmp->below)
        {
          if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
            {
              if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
                {
                  SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
                  if (op->type == PLAYER)
                    esrv_send_item (op, tmp);
                }
              if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
                  (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
                {
                  SET_FLAG (tmp, FLAG_KNOWN_CURSED);
                  if (op->type == PLAYER)
                    esrv_send_item (op, tmp);
                }
            }                   /* if item is not identified */
        }                       /* for the players inventory */
    }                           /* if detect magic/curse and object is a player */
  return 1;
}


/**
 * Checks if victim has overcharged mana. caster_level is the caster's (skill)
 * level whos spell did cause the overcharge.
 */
static void
charge_mana_effect (object *victim, int caster_level)
{

  /* Prevent explosions for objects without mana. Without this check, doors
   * will explode, too.
   */
  if (victim->stats.maxsp <= 0)
    return;

  new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");

  if (victim->stats.sp >= victim->stats.maxsp * 2)
    {
      object *tmp;

      new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");

      /* Explodes a fireball centered at player */
      tmp = get_archetype (EXPLODING_FIREBALL);
      tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
      tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;

      tmp->insert_at (victim);
      victim->stats.sp = 2 * victim->stats.maxsp;
    }
  else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
    new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");
  else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
    new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
  else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
    {
      new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
      confuse_player (victim, victim, 99);
    }
  else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
    new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
}

/* cast_transfer
 * This spell transfers sp from the player to another person.
 * We let the target go above their normal maximum SP.
 */

int
cast_transfer (object *op, object *caster, object *spell, int dir)
{
  object *plyr = NULL;
  sint16 x, y;
  maptile *m;
  int mflags;

  m = op->map;
  x = op->x + freearr_x[dir];
  y = op->y + freearr_y[dir];

  mflags = get_map_flags (m, &m, x, y, &x, &y);

  if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
    {
      for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
        if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
          break;
    }


  /* If we did not find a player in the specified direction, transfer
   * to anyone on top of us. This is used for the rune of transference mostly.
   */
  if (plyr == NULL)
    for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
      if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
        break;

  if (!plyr)
    {
      new_draw_info (NDI_BLACK, 0, op, "There is no one there.");
      return 0;
    }
  /* give sp */
  if (spell->stats.dam > 0)
    {
      plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
      charge_mana_effect (plyr, caster_level (caster, spell));
      return 1;
    }
  /* suck sp away.  Can't suck sp from yourself */
  else if (op != plyr)
    {
      /* old dragin magic used floats.  easier to just use ints and divide by 100 */

      int rate = -spell->stats.dam + SP_level_dam_adjust (caster, spell), sucked;

      if (rate > 95)
        rate = 95;

      sucked = (plyr->stats.sp * rate) / 100;
      plyr->stats.sp -= sucked;
      if (QUERY_FLAG (op, FLAG_ALIVE))
        {
          /* Player doesn't get full credit */
          sucked = (sucked * rate) / 100;
          op->stats.sp += sucked;
          if (sucked > 0)
            {
              charge_mana_effect (op, caster_level (caster, spell));
            }
        }
      return 1;
    }
  return 0;
}


/* counterspell:  nullifies spell effects.
 * op is the counterspell object, dir is the direction
 * it was cast in.
 * Basically, if the object has a magic attacktype,
 * this may nullify it.
 */
void
counterspell (object *op, int dir)
{
  object *tmp, *head, *next;
  int mflags;
  maptile *m;
  sint16 sx, sy;

  sx = op->x + freearr_x[dir];
  sy = op->y + freearr_y[dir];
  m = op->map;
  mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
  if (mflags & P_OUT_OF_MAP)
    return;

  for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
    {
      next = tmp->above;

      /* Need to look at the head object - otherwise, if tmp
       * points to a monster, we don't have all the necessary
       * info for it.
       */
      if (tmp->head)
        head = tmp->head;
      else
        head = tmp;

      /* don't attack our own spells */
      if (tmp->owner && tmp->owner == op->owner)
        continue;

      /* Basically, if the object is magical and not counterspell, 
       * we will more or less remove the object.  Don't counterspell
       * monsters either. 
       */

      if (head->attacktype & AT_MAGIC &&
          !(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level))
        head->destroy ();
      else
        switch (head->type)
          {
              case SPELL_EFFECT:
                if (op->level > head->level)
                  head->destroy ();

                break;

                /* I really don't get this rune code that much - that
                 * random chance seems really low.
                 */
              case RUNE:
                if (rndm (0, 149) == 0)
                  {
                    head->stats.hp--;   /* weaken the rune */
                    if (!head->stats.hp)
                      head->destroy ();
                  }
                break;
          }
    }
}


/* cast_consecrate() - a spell to make an altar your god's */
int
cast_consecrate (object *op, object *caster, object *spell)
{
  char buf[MAX_BUF];

  object *tmp, *god = find_god (determine_god (op));

  if (!god)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You can't consecrate anything if you don't worship a god!");
      return 0;
    }

  for (tmp = op->below; tmp; tmp = tmp->below)
    {
      if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
        break;
      if (tmp->type == HOLY_ALTAR)
        {

          if (tmp->level > caster_level (caster, spell))
            {
              new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
              return 0;
            }
          else
            {
              /* If we got here, we are consecrating an altar */
              sprintf (buf, "Altar of %s", &god->name);
              tmp->name = buf;
              tmp->level = caster_level (caster, spell);
              tmp->other_arch = god->arch;
              if (op->type == PLAYER)
                esrv_update_item (UPD_NAME, op, tmp);
              new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
              return 1;
            }
        }
    }
  new_draw_info (NDI_UNIQUE, 0, op, "You are not standing over an altar!");
  return 0;
}

/* animate_weapon - 
 * Generalization of staff_to_snake.  Makes a golem out of the caster's weapon.
 * The golem is based on the archetype specified, modified by the caster's level
 * and the attributes of the weapon.  The weapon is inserted in the golem's 
 * inventory so that it falls to the ground when the golem dies.
 * This code was very odd - code early on would only let players use the spell,
 * yet the code wass full of player checks.  I've presumed that the code
 * that only let players use it was correct, and removed all the other
 * player checks. MSW 2003-01-06
 */

int
animate_weapon (object *op, object *caster, object *spell, int dir)
{
  object *weapon, *tmp;
  char buf[MAX_BUF];
  int a, i;
  sint16 x, y;
  maptile *m;
  materialtype_t *mt;

  if (!spell->other_arch)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
      LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
      return 0;
    }
  /* exit if it's not a player using this spell. */
  if (op->type != PLAYER)
    return 0;

  /* if player already has a golem, abort */
  if (op->contr->ranges[range_golem])
    {
      control_golem (op->contr->ranges[range_golem], dir);
      return 0;
    }

  /* if no direction specified, pick one */
  if (!dir)
    dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9);

  m = op->map;
  x = op->x + freearr_x[dir];
  y = op->y + freearr_y[dir];

  /* if there's no place to put the golem, abort */
  if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||
      ((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type))
    {
      new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
      return 0;
    }

  /* Use the weapon marked by the player. */
  weapon = find_marked_object (op);

  if (!weapon)
    {
      new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
      return 0;
    }
  if (spell->race && strcmp (weapon->arch->name, spell->race))
    {
      new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
      return 0;
    }
  if (weapon->type != WEAPON)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
      return 0;
    }
  if (QUERY_FLAG (weapon, FLAG_APPLIED))
    {
      new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
      return 0;
    }

  if (weapon->nrof > 1)
    {
      tmp = get_split_ob (weapon, 1);
      esrv_send_item (op, weapon);
      weapon = tmp;
    }

  /* create the golem object */
  tmp = arch_to_object (spell->other_arch);

  /* if animated by a player, give the player control of the golem */
  CLEAR_FLAG (tmp, FLAG_MONSTER);
  tmp->stats.exp = 0;
  add_friendly_object (tmp);
  tmp->type = GOLEM;
  tmp->set_owner (op);
  set_spell_skill (op, caster, spell, tmp);
  op->contr->ranges[range_golem] = tmp;
  op->contr->shoottype = range_golem;

  /* Give the weapon to the golem now.  A bit of a hack to check the
   * removed flag - it should only be set if get_split_object was
   * used above.
   */
  if (!QUERY_FLAG (weapon, FLAG_REMOVED))
    weapon->remove ();
  insert_ob_in_ob (weapon, tmp);
  esrv_send_item (op, weapon);
  /* To do everything necessary to let a golem use the weapon is a pain,
   * so instead, just set it as equipped (otherwise, we need to update
   * body_info, skills, etc)
   */
  SET_FLAG (tmp, FLAG_USE_WEAPON);
  SET_FLAG (weapon, FLAG_APPLIED);
  tmp->update_stats ();

  /* There used to be 'odd' code that basically seemed to take the absolute
   * value of the weapon->magic an use that.  IMO, that doesn't make sense -
   * if you're using a crappy weapon, it shouldn't be as good.
   */

  /* modify weapon's animated wc */
  tmp->stats.wc = tmp->stats.wc - SP_level_range_adjust (caster, spell) - 5 * weapon->stats.Dex - 2 * weapon->stats.Str - weapon->magic;
  if (tmp->stats.wc < -127)
    tmp->stats.wc = -127;

  /* Modify hit points for weapon */
  tmp->stats.maxhp = tmp->stats.maxhp + spell->duration +
    SP_level_duration_adjust (caster, spell) + +8 * weapon->magic + 12 * weapon->stats.Con;
  if (tmp->stats.maxhp < 0)
    tmp->stats.maxhp = 10;
  tmp->stats.hp = tmp->stats.maxhp;

  /* Modify weapon's damage */
  tmp->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell) + weapon->stats.dam + weapon->magic + 5 * weapon->stats.Str;
  if (tmp->stats.dam < 0)
    tmp->stats.dam = 127;


  /* attacktype */
  if (!tmp->attacktype)
    tmp->attacktype = AT_PHYSICAL;

  mt = NULL;
  if (op->materialname != NULL)
    mt = name_to_material (op->materialname);
  if (mt != NULL)
    {
      for (i = 0; i < NROFATTACKS; i++)
        tmp->resist[i] = 50 - (mt->save[i] * 5);
      a = mt->save[0];
    }
  else
    {
      for (i = 0; i < NROFATTACKS; i++)
        tmp->resist[i] = 5;
      a = 10;
    }
  /* Set weapon's immunity */
  tmp->resist[ATNR_CONFUSION] = 100;
  tmp->resist[ATNR_POISON] = 100;
  tmp->resist[ATNR_SLOW] = 100;
  tmp->resist[ATNR_PARALYZE] = 100;
  tmp->resist[ATNR_TURN_UNDEAD] = 100;
  tmp->resist[ATNR_FEAR] = 100;
  tmp->resist[ATNR_DEPLETE] = 100;
  tmp->resist[ATNR_DEATH] = 100;
  tmp->resist[ATNR_BLIND] = 100;

  /* Improve weapon's armour value according to best save vs. physical of its material */

  if (a > 14)
    a = 14;
  tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));

  /* Determine golem's speed */
  tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));

  if (!spell->race)
    {
      sprintf (buf, "animated %s", &weapon->name);
      tmp->name = buf;

      tmp->face = weapon->face;
      tmp->animation_id = weapon->animation_id;
      tmp->anim_speed = weapon->anim_speed;
      tmp->last_anim = weapon->last_anim;
      tmp->state = weapon->state;
      tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
    }

  /*  make experience increase in proportion to the strength of the summoned creature. */
  tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));

  tmp->speed_left = -1;
  tmp->direction = dir;

  m->insert (tmp, x, y, op);
  return 1;
}

/* cast_daylight() - changes the map darkness level *lower* */

/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
 * This changes the light level for the entire map.
 */

int
cast_change_map_lightlevel (object *op, object *caster, object *spell)
{
  int success;

  if (!op->map)
    return 0;                   /* shouldnt happen */

  success = op->map->change_map_light (spell->stats.dam);

  if (!success)
    {
      if (spell->stats.dam < 0)
        new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
      else
        new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
    }
  return success;
}


/* create an aura spell object and put it in the player's inventory.
 * as usual, op is player, caster is the object casting the spell,
 * spell is the spell object itself.
 */
int
create_aura (object *op, object *caster, object *spell)
{
  int refresh = 0;
  object *new_aura;

  new_aura = present_arch_in_ob (spell->other_arch, op);
  if (new_aura)
    refresh = 1;
  else
    new_aura = arch_to_object (spell->other_arch);

  new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);

  new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);

  new_aura->set_owner (op);
  set_spell_skill (op, caster, spell, new_aura);
  new_aura->attacktype = spell->attacktype;

  new_aura->level = caster_level (caster, spell);
  if (refresh)
    new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
  else
    new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
  insert_ob_in_ob (new_aura, op);
  return 1;
}


/* move aura function.  An aura is a part of someone's inventory,
 * which he carries with him, but which acts on the map immediately
 * around him.
 * Aura parameters:
 * duration:  duration counter.   
 * attacktype:  aura's attacktype 
 * other_arch:  archetype to drop where we attack
 */

void
move_aura (object *aura)
{
  int i, mflags;
  object *env;
  maptile *m;

  /* auras belong in inventories */
  env = aura->env;

  /* no matter what we've gotta remove the aura...
   * we'll put it back if its time isn't up.  
   */
  aura->remove ();

  /* exit if we're out of gas */
  if (aura->duration-- < 0)
    {
      aura->destroy ();
      return;
    }

  /* auras only exist in inventories */
  if (env == NULL || env->map == NULL)
    {
      aura->destroy ();
      return;
    }

  /* we need to jump out of the inventory for a bit
   * in order to hit the map conveniently. 
   */
  aura->insert_at (env, aura);

  for (i = 1; i < 9; i++)
    {
      sint16 nx, ny;

      nx = aura->x + freearr_x[i];
      ny = aura->y + freearr_y[i];
      mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);

      /* Consider the movement tyep of the person with the aura as
       * movement type of the aura.  Eg, if the player is flying, the aura
       * is flying also, if player is walking, it is on the ground, etc.
       */
      if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))
        {
          hit_map (aura, i, aura->attacktype, 0);

          if (aura->other_arch)
            m->insert (arch_to_object (aura->other_arch), nx, ny, aura);
        }
    }

  /* put the aura back in the player's inventory */
  aura->remove ();
  insert_ob_in_ob (aura, env);
}

/* moves the peacemaker spell.
 * op is the piece object.
 */

void
move_peacemaker (object *op)
{
  object *tmp;

  for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
    {
      int atk_lev, def_lev;
      object *victim = tmp;

      if (tmp->head)
        victim = tmp->head;
      if (!QUERY_FLAG (victim, FLAG_MONSTER))
        continue;
      if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
        continue;
      if (victim->stats.exp == 0)
        continue;

      def_lev = MAX (1, victim->level);
      atk_lev = MAX (1, op->level);

      if (rndm (0, atk_lev - 1) > def_lev)
        {
          /* make this sucker peaceful. */

          change_exp (op->owner, victim->stats.exp, op->skill, 0);
          victim->stats.exp = 0;
#if 0
          /* No idea why these were all set to zero - if something
           * makes this creature agressive, he should still do damage.
           */
          victim->stats.dam = 0;
          victim->stats.sp = 0;
          victim->stats.grace = 0;
          victim->stats.Pow = 0;
#endif
          victim->attack_movement = RANDO2;
          SET_FLAG (victim, FLAG_UNAGGRESSIVE);
          SET_FLAG (victim, FLAG_RUN_AWAY);
          SET_FLAG (victim, FLAG_RANDOM_MOVE);
          CLEAR_FLAG (victim, FLAG_MONSTER);
          if (victim->name)
            {
              new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
            }
        }
    }
}


/* This writes a rune that contains the appropriate message.
 * There really isn't any adjustments we make.
 */

int
write_mark (object *op, object *spell, const char *msg)
{
  char rune[HUGE_BUF];
  object *tmp;

  if (!msg || msg[0] == 0)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
      return 0;
    }

  if (strcasestr_local (msg, "endmsg"))
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
      LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);
      return 0;
    }
  if (!spell->other_arch)
    return 0;
  tmp = arch_to_object (spell->other_arch);

  snprintf (rune, sizeof (rune), "%s\n", msg);

  tmp->race = op->name;         /*Save the owner of the rune */
  tmp->msg = rune;

  tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
  return 1;
}
Revision:	1.42
Committed:	Wed Mar 14 04:12:29 2007 UTC (17 years, 2 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.41:	+2 -1 lines
Log Message:	- rewrote more face handling code - automatically send smooth faces, as the client will need them anyways and it makes little sense to wait for the client to axk for it. of course, gcfclient suffers from weird ordering problems again. - UP_OBJ_FACE was often abused in situations where other things changed, updated lots of spaces, probably more to be done. - update_smooth became so small that inlining it actually clarified the code. similar for update_space, which is not inlined for other reasons. - faces were not initialised properly - add versioncheck for face data - rewrite invisibility handling a bit: god finger etc. now makes you blink, blinking routine has changed to be less annoying and more useful while still indicating invisibleness.