server/common/loader.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>
 */

/* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
   sub/add_weight will transcend the environment updating the carrying
   variable. */

#include <global.h>
#include <loader.h>
#include <sproto.h>

/////////////////////////////////////////////////////////////////////////////

loader_base::~loader_base ()
{
}

// the base class warns about and skips everything
archetype *
loader_base::get_arch (const char *name)
{
  LOG (llevError, "%s: found archetype definition '%s', which is not allowed in files of this type.\n",
       filename, name);

  return new archetype;
}

object *
loader_base::get_object  (const char *name)
{
  LOG (llevError, "%s: found object definition '%s', which is not allowed in files of this type.\n",
       filename, name);

  return object::create ();
}

player *
loader_base::get_player  ()
{
  LOG (llevError, "%s: found player definition, which is not allowed in files of this type.\n",
       filename);

  return player::create ();
}

region *
loader_base::get_region  (const char *name)
{
  LOG (llevError, "%s: found region definition '%s', which is not allowed in files of this type.\n",
       filename, name);

  return new region;
}

facetile *
loader_base::get_face  (const char *name)
{
  LOG (llevError, "%s: found face definition '%s', which is not allowed in files of this type.\n",
       filename, name);

  return new facetile;
}

treasurelist *
loader_base::get_treasure (const char *name, bool one)
{
  LOG (llevError, "%s: found treasure definition '%s', which is not allowed in files of this type.\n",
       filename, name);

  return new treasurelist;//D
}

animation *
loader_base::get_animation (const char *name)
{
  LOG (llevError, "%s: found animation definition '%s', which is not allowed in files of this type.\n",
       filename, name);

  return new animation;
}

void 
loader_base::put_arch       (archetype *arch)
{
  delete arch;
}

void 
loader_base::put_object     (object *op)
{
  op->destroy ();
}

void 
loader_base::put_player     (player *pl)
{
  delete pl;
}

void 
loader_base::put_region     (region *region)
{
  delete region;
}

void 
loader_base::put_face       (facetile *face)
{
  delete face;
}

void 
loader_base::put_treasure (treasurelist *treasure)
{
  delete treasure;
}

void 
loader_base::put_animation (animation *anim)
{
  delete anim;
}

/////////////////////////////////////////////////////////////////////////////

bool loader_base::parse (object_thawer &thawer)
{
  for (;;)
    {
      keyword kw = thawer.get_kv ();

      switch (kw)
        {
          case KW_region:
            {
              region *rgn = get_region (thawer.get_str ());

              if (!parse_region (thawer, rgn))
                {
                  delete rgn;
                  return false;
                }

              put_region (rgn);
            }
            break;

          case KW_EOF:
            return true;

          default:
            if (!thawer.parse_error (kw, "resource file"))
              return false;
        }
    }
}

bool loader_base::load (const char *filename)
{
  this->filename = filename;

  object_thawer fp (filename);

  if (!fp)
    return false;

  return parse (fp);
}

/////////////////////////////////////////////////////////////////////////////

/* Maps the MOVE_* values to names */
static const char *const move_name[] = { "walk", "fly_low", "fly_high", "swim", "boat", NULL };

/* This table is only necessary to convert objects that existed before the
 * spell object conversion to the new object.  It was not practical
 * to go through every mapping looking for every potion, rod, wand, etc
 * that had a sp set and update to the new value.  So this maps the
 * old spell numbers to the name of the new archs.
 * If you are adding a new spell, you should not modify this - you
 * new spell won't have been used, and thus won't have any legacy object.
 * NULL entries in this table are valid - to denote objects that should
 * not be updated for whatever reason.
 */
const char *spell_mapping[] = {
  "spell_magic_bullet",         /* 0 */
  "spell_small_fireball",       /* 1 */
  "spell_medium_fireball",      /* 2 */
  "spell_large_fireball",       /* 3 */
  "spell_burning_hands",        /* 4 */
  "spell_sm_lightning",         /* 5 */
  "spell_large_lightning",      /* 6 */
  "spell_magic_missile",        /* 7 */
  "spell_create_bomb",          /* 8 */
  "spell_summon_golem",         /* 9 */
  "spell_summon_fire_elemental",        /* 10 */
  "spell_summon_earth_elemental",       /* 11 */
  "spell_summon_water_elemental",       /* 12 */
  "spell_summon_air_elemental", /* 13 */
  "spell_dimension_door",       /* 14 */
  "spell_create_earth_wall",    /* 15 */
  "spell_paralyze",             /* 16 */
  "spell_icestorm",             /* 17 */
  "spell_magic_mapping",        /* 18 */
  "spell_turn_undead",          /* 19 */
  "spell_fear",                 /* 20 */
  "spell_poison_cloud",         /* 21 */
  "spell_wonder",               /* 22 */
  "spell_destruction",          /* 23 */
  "spell_perceive_self",        /* 24 */
  "spell_word_of_recall",       /* 25 */
  "spell_invisible",            /* 26 */
  "spell_invisible_to_undead",  /* 27 */
  "spell_probe",                /* 28 */
  "spell_lg_magic_bullet",      /* 29 */
  "spell_improved_invisibility",        /* 30 */
  "spell_holy_word",            /* 31 */
  "spell_minor_healing",        /* 32 */
  "spell_medium_healing",       /* 33 */
  "spell_major_healing",        /* 34 */
  "spell_heal",                 /* 35 */
  "spell_create_food",          /* 36 */
  "spell_earth_to_dust",        /* 37 */
  "spell_armour",               /* 38 */
  "spell_strength",             /* 39 */
  "spell_dexterity",            /* 40 */
  "spell_constitution",         /* 41 */
  "spell_charisma",             /* 42 */
  "spell_create_fire_wall",     /* 43 */
  "spell_create_frost_wall",    /* 44 */
  "spell_protection_from_cold", /* 45 */
  "spell_protection_from_electricity",  /* 46 */
  "spell_protection_from_fire", /* 47 */
  "spell_protection_from_poison",       /* 48 */
  "spell_protection_from_slow", /* 49 */
  "spell_protection_from_paralysis",    /* 50 */
  "spell_protection_from_draining",     /* 51 */
  "spell_protection_from_magic",        /* 52 */
  "spell_protection_from_attack",       /* 53 */
  "spell_levitate",             /* 54 */
  "spell_small_speedball",      /* 55 */
  "spell_large_speedball",      /* 56 */
  "spell_hellfire",             /* 57 */
  "spell_dragonbreath",         /* 58 */
  "spell_large_icestorm",       /* 59 */
  "spell_charging",             /* 60 */
  "spell_polymorph",            /* 61 */
  "spell_cancellation",         /* 62 */
  "spell_confusion",            /* 63 */
  "spell_mass_confusion",       /* 64 */
  "spell_summon_pet_monster",   /* 65 */
  "spell_slow",                 /* 66 */
  "spell_regenerate_spellpoints",       /* 67 */
  "spell_cure_poison",          /* 68 */
  "spell_protection_from_confusion",    /* 69 */
  "spell_protection_from_cancellation", /* 70 */
  "spell_protection_from_depletion",    /* 71 */
  "spell_alchemy",              /* 72 */
  "spell_remove_curse",         /* 73 */
  "spell_remove_damnation",     /* 74 */
  "spell_identify",             /* 75 */
  "spell_detect_magic",         /* 76 */
  "spell_detect_monster",       /* 77 */
  "spell_detect_evil",          /* 78 */
  "spell_detect_curse",         /* 79 */
  "spell_heroism",              /* 80 */
  "spell_aggravation",          /* 81 */
  "spell_firebolt",             /* 82 */
  "spell_frostbolt",            /* 83 */
  "spell_shockwave",            /* 84 */
  "spell_color_spray",          /* 85 */
  "spell_haste",                /* 86 */
  "spell_face_of_death",        /* 87 */
  "spell_ball_lightning",       /* 88 */
  "spell_meteor_swarm",         /* 89 */
  "spell_comet",                /* 90 */
  "spell_mystic_fist",          /* 91 */
  "spell_raise_dead",           /* 92 */
  "spell_resurrection",         /* 93 */
  "spell_reincarnation",        /* 94 */
  "spell_immunity_to_cold",     /* 95 */
  "spell_immunity_to_electricity",      /* 96 */
  "spell_immunity_to_fire",     /* 97 */
  "spell_immunity_to_poison",   /* 98 */
  "spell_immunity_to_slow",     /* 99 */
  "spell_immunity_to_paralysis",        /* 100 */
  "spell_immunity_to_draining", /* 101 */
  "spell_immunity_to_magic",    /* 102 */
  "spell_immunity_to_attack",   /* 103 */
  "spell_invulnerability",      /* 104 */
  "spell_defense",              /* 105 */
  "spell_rune_of_fire",         /* 106 */
  "spell_rune_of_frost",        /* 107 */
  "spell_rune_of_shocking",     /* 108 */
  "spell_rune_of_blasting",     /* 109 */
  "spell_rune_of_death",        /* 110 */
  "spell_marking_rune",         /* 111 */
  "spell_build_director",       /* 112 */
  "spell_create_pool_of_chaos", /* 113 */
  "spell_build_bullet_wall",    /* 114 */
  "spell_build_lightning_wall", /* 115 */
  "spell_build_fireball_wall",  /* 116 */
  "spell_magic_rune",           /* 117 */
  "spell_rune_of_magic_drain",  /* 118 */
  "spell_antimagic_rune",       /* 119 */
  "spell_rune_of_transference", /* 120 */
  "spell_transference",         /* 121 */
  "spell_magic_drain",          /* 122 */
  "spell_counterspell",         /* 123 */
  "spell_disarm",               /* 124 */
  "spell_cure_confusion",       /* 125 */
  "spell_restoration",          /* 126 */
  "was summon evil monster",    /* 127 *//* Not implenented as nothing used it */
  "spell_counterwall",          /* 128 */
  "spell_cause_light_wounds",   /* 129 */
  "spell_cause_medium_wounds",  /* 130 */
  "spell_cause_heavy_wounds",   /* 131 */
  "spell_charm_monsters",       /* 132 */
  "spell_banishment",           /* 133 */
  "spell_create_missile",       /* 134 */
  "spell_show_invisible",       /* 135 */
  "spell_xray",                 /* 136 */
  "spell_pacify",               /* 137 */
  "spell_summon_fog",           /* 138 */
  "spell_steambolt",            /* 139 */
  "spell_command_undead",       /* 140 */
  "spell_holy_orb",             /* 141 */
  "spell_summon_avatar",        /* 142 */
  "spell_holy_possession",      /* 143 */
  "spell_bless",                /* 144 */
  "spell_curse",                /* 145 */
  "spell_regeneration",         /* 146 */
  "spell_consecrate",           /* 147 */
  "spell_summon_cult_monsters", /* 148 */
  "spell_cause_critical_wounds",        /* 149 */
  "spell_holy_wrath",           /* 150 */
  "spell_retributive_strike",   /* 151 */
  "spell_finger_of_death",      /* 152 */
  "spell_insect_plague",        /* 153 */
  "spell_call_holy_servant",    /* 154 */
  "spell_wall_of_thorns",       /* 155 */
  "spell_staff_to_snake",       /* 156 */
  "spell_light",                /* 157 */
  "spell_darkness",             /* 158 */
  "spell_nightfall",            /* 159 */
  "spell_daylight",             /* 160 */
  "spell_sunspear",             /* 161 */
  "spell_faery_fire",           /* 162 */
  "spell_cure_blindness",       /* 163 */
  "spell_dark_vision",          /* 164 */
  "spell_bullet_swarm",         /* 165 */
  "spell_bullet_storm",         /* 166 */
  "spell_cause_many_wounds",    /* 167 */
  "spell_small_snowstorm",      /* 168 */
  "spell_medium_snowstorm",     /* 169 */
  "spell_large_snowstorm",      /* 170 */
  "spell_cure_disease",         /* 171 */
  "spell_cause_red_death",      /* 172 */
  "spell_cause_flu",            /* 173 */
  "spell_cause_black_death",    /* 174 */
  "spell_cause_leprosy",        /* 175 */
  "spell_cause_smallpox",       /* 176 */
  "spell_cause_white_death",    /* 177 */
  "spell_cause_anthrax",        /* 178 */
  "spell_cause_typhoid",        /* 179 */
  "spell_mana_blast",           /* 180 */
  "spell_small_manaball",       /* 181 */
  "spell_medium_manaball",      /* 182 */
  "spell_large_manaball",       /* 183 */
  "spell_manabolt",             /* 184 */
  "spell_dancing_sword",        /* 185 */
  "spell_animate_weapon",       /* 186 */
  "spell_cause_cold",           /* 187 */
  "spell_divine_shock",         /* 188 */
  "spell_windstorm",            /* 189 */
  "spell_sanctuary",            /* 190 */
  "spell_peace",                /* 191 */
  "spell_spiderweb",            /* 192 */
  "spell_conflict",             /* 193 */
  "spell_rage",                 /* 194 */
  "spell_forked_lightning",     /* 195 */
  "spell_poison_fog",           /* 196 */
  "spell_flaming_aura",         /* 197 */
  "spell_vitriol",              /* 198 */
  "spell_vitriol_splash",       /* 199 */
  "spell_iron_skin",            /* 200 */
  "spell_wrathful_eye",         /* 201 */
  "spell_town_portal",          /* 202 */
  "spell_missile_swarm",        /* 203 */
  "spell_cause_rabies",         /* 204 */
  "spell_glyph",                /* 205 */
  NULL
};

extern int arch_init;

/* This function checks the object after it has been loaded (when we
 * get the 'end' in the input stream).  This function can be used to 
 * deal with legacy objects where fields may have changed.  It can also be used
 * to check for objects to make sure there are no common errors.
 */
static void
check_loaded_object (object *op)
{
  int ip;

  /* We do some specialised handling to handle legacy cases of name_pl.
   * If the object doesn't have a name_pl, we just use the object name -
   * this isn't perfect (things won't be properly pluralised), but works to
   * that degree (5 heart is still quite understandable).  But the case we
   * also have to catch is if this object is not using the normal name for
   * the object.  In that case, we also want to use the loaded name.
   * Otherwise, what happens is that the the plural name will lose
   * information (appear as just 'hearts' and not 'goblins heart') 
   */
  if (op->arch && op->name != op->arch->clone.name && op->name_pl == op->arch->clone.name_pl)
    op->name_pl = NULL;

  if (!op->name_pl)
    op->name_pl = op->name;

  /* objects now have a materialname.  try to patch it in */
  if (!(op->is_weapon () && op->level > 0))
    {
      if (op->map != NULL)
        set_materialname (op, op->map->difficulty, NULL);
      else
        set_materialname (op, 5, NULL);
    }
  /* only do these when program is first run - a bit
   * excessive to do this at every run - most of this is
   * really just to catch any errors - program will still run, but
   * not in the ideal fashion.
   */
  if ((op->type == WEAPON || op->type == BOW) && arch_init)
    {
      if (!op->skill)
        {
          LOG (llevError, "Weapon %s lacks a skill.\n", op->debug_desc ());
        }
      else if ((!strcmp (op->skill, "one handed weapons") && op->body_info[1] != -1) ||
               (!strcmp (op->skill, "two handed weapons") && op->body_info[1] != -2))
        {
          LOG (llevError, "weapon %s arm usage does not match skill: %d, %s\n", op->debug_desc (), op->body_info[1], &op->skill);
        }
    }

  /* We changed last_heal to gen_sp_armour, which is what it
   * really does for many objects.  Need to catch any in maps
   * that may have an old value.
   */
  if ((op->type == WEAPON) ||
      (op->type == ARMOUR) || (op->type == HELMET) ||
      (op->type == SHIELD) || (op->type == RING) ||
      (op->type == BOOTS) || (op->type == GLOVES) ||
      (op->type == AMULET) || (op->type == GIRDLE) || (op->type == BRACERS) || (op->type == CLOAK))
    {
      if (op->last_heal)
        {
          LOG (llevDebug, "Object %s still has last_heal set, not gen_sp_armour\n", op->debug_desc ());
          op->gen_sp_armour = op->last_heal;
          op->last_heal = 0;
        }

      ip = calc_item_power (op, 0);
      /* Legacy objects from before item power was in the game */
      if (!op->item_power && ip)
        {
          if (ip > 3)
            {
              LOG (llevDebug, "Object %s had no item power, using %d\n", op->debug_desc (), ip);
            }
          op->item_power = ip;
        }
      /* Check for possibly bogus values.  Has to meet both these criteria -
       * something that has item_power 1 is probably just fine if our calculated
       * value is 1 or 2 - these values are small enough that hard to be precise.
       * similarly, it item_power is 0, the first check will always pass,
       * but not the second one.
       */
      if (ip > 2 * op->item_power && ip > (op->item_power + 3))
        {
          LOG (llevDebug, "Object %s seems to have too low item power? %d > %d\n", op->debug_desc (), ip, op->item_power);
        }

    }
  /* Old spellcasting object - need to load in the appropiate object */
  if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN || op->type == FIREWALL ||
       /* POTIONS and ALTARS don't always cast spells, but if they do, update them */
       ((op->type == POTION || op->type == ALTAR) && op->stats.sp)) && !op->inv && !arch_init)
    {
      object *tmp;

      /* Fireall is bizarre in that spell type was stored in dam.  Rest are 'normal'
       * in that spell was stored in sp.
       */
      tmp = get_archetype (spell_mapping[op->type == FIREWALL ? op->stats.dam : op->stats.sp]);
      insert_ob_in_ob (tmp, op);
      op->randomitems = NULL;   /* So another spell isn't created for this object */
    }
  /* spellbooks & runes use slaying.  But not to arch name, but to spell name */

  if ((op->type == SPELLBOOK || op->type == RUNE) && op->slaying && !op->inv && !arch_init)
    {
      object *tmp;

      tmp = get_archetype_by_object_name (op->slaying);
      insert_ob_in_ob (tmp, op);
      op->randomitems = NULL;   /* So another spell isn't created for this object */
      /* without this, value is all screwed up */
      op->value = op->arch->clone.value * op->inv->value;
    }

  if (QUERY_FLAG (op, FLAG_MONSTER))
    {
      if (op->stats.hp > op->stats.maxhp)
        {
          LOG (llevDebug, "Monster %s has hp set higher than maxhp (%d>%d)\n", op->debug_desc (), op->stats.hp, op->stats.maxhp);
          op->stats.maxhp = op->stats.hp;
        }

      /* The archs just need to be updated for this */
      if (op->move_type == 0)
        op->move_type = MOVE_WALK;
    }

  if ((QUERY_FLAG (op, FLAG_GENERATOR) && QUERY_FLAG (op, FLAG_CONTENT_ON_GEN)) || op->type == CREATOR || op->type == CONVERTER)
    {
      /* Object will duplicate it's content as part of the
       * generation process. To do this, we must flag inventory
       * so it remains unevaluated concerning the randomitems and
       * the living (a demonlord shouldn't cast from inside generator!)
       */
      flag_inv (op, FLAG_IS_A_TEMPLATE);
    }

  /* Handle player movers.  We use move_type for player movers
   * because they operate on their own time (move_on
   * would potentially cause them to be triggered when someone steps
   * on them).  If move_type is set, presume person knows what they
   * are doing, otherwise, set move_type based on maxhp value.
   */
  if (op->type == PLAYERMOVER)
    {
      if (!op->move_type)
        {
          if (op->stats.maxhp)
            {
              op->move_type = MOVE_ALL;
              op->stats.maxhp = 0;
            }
          else
            {
              op->move_type = MOVE_WALK;
            }
        }
    }

}

static void
set_move (MoveType & mt, const char *str)
{
  if (!str)
    {
      mt = 0;
      return;
    }

  if (isdigit (*str))
    {
      mt = atoi (str);
      return;
    }

  mt = 0;

  for (str = strtok ((char *) str, " "); str; str = strtok (0, " "))
    {
      if (!strcasecmp (str, "all"))
        mt |= MOVE_ALL;
      else
        {
          int i, negate = 0;

          if (*str == '-')
            {
              negate = 1;
              str++;
            }

          for (i = 0; move_name[i]; i++)
            {
              if (!strcasecmp (move_name[i], str))
                {
                  if (negate)
                    mt &= ~(1 << i);
                  else
                    mt |= (1 << i);

                  break;
                }
            }

          if (!move_name[i])
            {
              /* fly is a special case - covers both fly_low and
               * fly_high - since it doesn't match to a specific
               * single bit, have to special case it.
               */
              if (!strcasecmp (str, "flying"))
                {
                  if (negate)
                    mt &= ~MOVE_FLYING;
                  else
                    mt |= MOVE_FLYING;
                }
              else
                LOG (llevDebug, "common/loader.l: set_move - unknown move string '%s'\n", str);
            }
        }
    }
}

#define GET_FLAG(op,flag)       \
  if (thawer.get_sint32 ())     \
    SET_FLAG (op, flag);        \
  else                          \
    CLEAR_FLAG (op, flag)       \

int
parse_object (object *op, object_thawer &thawer, int map_flags)
{
  bool ismore = 0;
  object *op_inv = op->inv;

  for (;;)
    {
      keyword kw = thawer.get_kv ();

      switch (kw)
        {
          case KW_Object:    // uppercase alias
          case KW_object:
            thawer.get (op->name);

            if (op->arch)
              op->arch->name = op->name;

            break;

          case KW_uuid:
            if (const char *s = thawer.get_str ())
              {
                unsigned int version;
                unsigned long long seq;

                if (2 == sscanf (s, "<%d.%llx>", &version, &seq) && version == 1)
                  {
                    op->uuid.seq = seq;
                    break;
                  }
              }

            op->uuid = gen_uuid ();
            break;

          case KW_oid:
            thawer.get (op, thawer.get_sint32 ());
            break;

          case KW_name:         thawer.get (op->name); break;
          case KW_name_pl:      thawer.get (op->name_pl); break;
          case KW_title:        thawer.get (op->title); break;
          case KW_custom_name:  thawer.get (op->custom_name); break;

          case KW_attach:       thawer.get_ornull (op->attach); break;
          case KW_skill:        thawer.get_ornull (op->skill); break;
          case KW_race:         thawer.get_ornull (op->race); break;
          case KW_slaying:      thawer.get_ornull (op->slaying); break;

          case KW_arch:
            {
              const char *str = thawer.get_str ();

              if (op->arch)
                {
                  /* If op->arch has been set, then this new object
                   * must be part of the inventory.  So process
                   * appropriately.
                   */
                  archetype *arch = archetype::find (str);

                  object *tmp;

                  if (arch)
                    tmp = arch_to_object (arch);
                  else
                    {
                      tmp = object::create ();
                      /* record the name of the broken object */
                      //TODO: but do not log???
                      tmp->name = str;
                    }

                  // decativate the object we, as we are still going
                  // to read the speed value. Objects should be activated
                  // when the map, object or player is completly loaded.
                  tmp->deactivate ();

                  parse_object (tmp, thawer, map_flags);

                  if (tmp->arch)
                    {
                      // was: insert_ob_in_ob (tmp, op);
                      // but manually adding it can improve map loading times a lot
                      // also, appending instead of prepending keeps the
                      // save ordering the same between repeated load/saves.
                      CLEAR_FLAG (tmp, FLAG_OBJ_ORIGINAL);
                      CLEAR_FLAG (tmp, FLAG_REMOVED);

                      if (!op_inv)
                        {
                          op->inv = tmp;
                          tmp->above = 0;
                        }
                      else
                        {
                          while (op_inv->below)
                            op_inv = op_inv->below;

                          op_inv->below = tmp;
                          tmp->above = op_inv;
                        }

                      tmp->below = 0;
                      tmp->env = op;
                      op_inv = tmp;
                    }
                  else
                    {
                      LOG (llevDebug, "Discarding object without arch: %s\n", tmp->name ? (const char *) tmp->name : "(null)");
                      tmp->destroy ();
                    }
                }
              else
                {
                  /* This is the actual archetype definition then */
                  op->arch = archetype::find (str);

                  if (op->arch)
                    {
                      op->arch->clone.copy_to (op);
                      // copy_to activates, this should be fixed properly
                      op->deactivate ();
                    }
                  else if (!arch_init)
                    /* record the name of the broken object */
                    op->name = str;
                }
            }
            break;

          case KW_other_arch:
            op->other_arch = archetype::find (thawer.get_str ());
            break;

          case KW_animation:
            {
              CLEAR_FLAG (op, FLAG_ANIMATE);
              op->animation_id = 0;

              const char *str = thawer.get_str ();
              if (str && (op->animation_id = find_animation (str)))
                SET_FLAG (op, FLAG_ANIMATE);
            }
            break;

          case KW_last_heal:  thawer.get (op->last_heal);  break;
          case KW_last_sp:    thawer.get (op->last_sp);    break;
          case KW_last_grace: thawer.get (op->last_grace); break;
          case KW_last_eat:   thawer.get (op->last_eat);   break;
          case KW_speed_left: thawer.get (op->speed_left); break;

          case KW_speed:
            thawer.get (op->speed);

            //TODO: maybe do in check_object
            // removed check for style maps
            if (op->speed < 0)
              op->speed_left = op->speed_left - rndm ();

            break;

          case KW_slow_move:
            op->move_slow |= MOVE_WALK;
            thawer.get (op->move_slow_penalty);
            break;

          case KW_face:
            op->face = &new_faces[FindFace (thawer.get_str (), 0)];
            break;

          case KW_x: thawer.get (op->x); break;
          case KW_y: thawer.get (op->y); break;

          case KW_Str:       // uppercase alias
          case KW_str: thawer.get (op->stats.Str); break;
          case KW_Dex:       // uppercase alias
          case KW_dex: thawer.get (op->stats.Dex); break;
          case KW_Con:       // uppercase alias
          case KW_con: thawer.get (op->stats.Con); break;
          case KW_Wis:       // uppercase alias
          case KW_wis: thawer.get (op->stats.Wis); break;
          case KW_Cha:       // uppercase alias
          case KW_cha: thawer.get (op->stats.Cha); break;
          case KW_Int:       // uppercase alias
          case KW_int: thawer.get (op->stats.Int); break;
          case KW_Pow:       // uppercase alias
          case KW_pow: thawer.get (op->stats.Pow); break;

          case KW_hp:                   thawer.get (op->stats.hp); break;
          case KW_maxhp:                thawer.get (op->stats.maxhp); break;
          case KW_sp:                   thawer.get (op->stats.sp); break;
          case KW_maxsp:                thawer.get (op->stats.maxsp); break;
          case KW_grace:                thawer.get (op->stats.grace); break;
          case KW_maxgrace:             thawer.get (op->stats.maxgrace); break;

          case KW_exp:                  thawer.get (op->stats.exp); break;
          case KW_perm_exp:             thawer.get (op->perm_exp); break;
          case KW_food:                 thawer.get (op->stats.food); break;
          case KW_dam:                  thawer.get (op->stats.dam); break;
          case KW_wc:                   thawer.get (op->stats.wc); break;
          case KW_ac:                   thawer.get (op->stats.ac); break;
          case KW_nrof:                 thawer.get (op->nrof); break;
          case KW_level:                thawer.get (op->level); break;
          case KW_direction:            thawer.get (op->direction); break;
          case KW_type:                 thawer.get (op->type); break;
          case KW_subtype:              thawer.get (op->subtype); break;
          case KW_value:                thawer.get (op->value); break;
          case KW_weight:               thawer.get (op->weight); break;
          case KW_carrying:             thawer.get (op->carrying); break;
          case KW_attacktype:           thawer.get (op->attacktype); break;
          case KW_path_attuned:         thawer.get (op->path_attuned); break;
          case KW_path_repelled:        thawer.get (op->path_repelled); break;
          case KW_path_denied:          thawer.get (op->path_denied); break;
          case KW_invisible:            thawer.get (op->invisible); break;
          case KW_magic:                thawer.get (op->magic); break;
          case KW_state:                thawer.get (op->state); break;
          case KW_move_slow_penalty:    thawer.get (op->move_slow_penalty); break;
          case KW_material:             thawer.get (op->materials); break; //TODO: nuke
          case KW_materialname:         thawer.get (op->materialname); break;

            /* These are the new values */
          case KW_move_block:           set_move (op->move_block, thawer.get_str ()); break;
          case KW_move_allow:           set_move (op->move_allow, thawer.get_str ()); break;
          case KW_move_type:            set_move (op->move_type, thawer.get_str ()); break;
          case KW_move_on:              set_move (op->move_on, thawer.get_str ()); break;
          case KW_move_off:             set_move (op->move_off, thawer.get_str ()); break;
          case KW_move_slow:            set_move (op->move_slow, thawer.get_str ()); break;

            /* These are all legacy - any new objects should use the move_ .. values */
          case KW_no_pass:
            {
              if (thawer.get_sint32 ())
                op->move_block = MOVE_ALL;
              else
                op->move_block = 0;
            }

            break;

            /* These are all legacy - any new objects should use the move_ .. values */
          case KW_walk_on:
            {
              if (thawer.get_sint32 ())
                op->move_on |= MOVE_WALK;
              else
                op->move_on &= ~MOVE_WALK;
            }

            break;

            /* These are all legacy - any new objects should use the move_ .. values */
          case KW_walk_off:
            {
              if (thawer.get_sint32 ())
                op->move_off |= MOVE_WALK;
              else
                op->move_off &= ~MOVE_WALK;
            }
            break;

            /* These are all legacy - any new objects should use the move_ .. values */
          case KW_fly_on:
            {
              if (thawer.get_sint32 ())
                op->move_on |= MOVE_FLY_LOW;
              else
                op->move_on &= ~MOVE_FLY_LOW;
            }
            break;

            /* These are all legacy - any new objects should use the move_ .. values */
          case KW_fly_off:
            {
              if (thawer.get_sint32 ())
                op->move_off |= MOVE_FLY_LOW;
              else
                op->move_off &= ~MOVE_FLY_LOW;
            }
            break;

            //TODO: remove these after converting archetypes
          case KW_can_use_wand:
            GET_FLAG (op, FLAG_USE_RANGE);
            break;

            /* These are all legacy - any new objects should use the move_ .. values */
          case KW_flying:
            {
              if (thawer.get_sint32 ())
                op->move_type |= MOVE_FLY_LOW;
              else
                op->move_type &= ~MOVE_FLY_LOW;
            }
            break;


          case KW_identified:
            GET_FLAG (op, FLAG_IDENTIFIED);
            //TODO: move to check_object or so
            if (QUERY_FLAG (op, FLAG_IDENTIFIED))
              CLEAR_FLAG (op, FLAG_KNOWN_MAGICAL);

            break;

          case KW_wiz:
            GET_FLAG (op, FLAG_WIZ);
            //TODO: move to check_object
            if (QUERY_FLAG (op, FLAG_WIZ))
              {
                SET_FLAG (op, FLAG_WAS_WIZ);
                SET_FLAG (op, FLAG_WIZPASS);
                SET_FLAG (op, FLAG_WIZCAST);
              }
            else
              {
                CLEAR_FLAG (op, FLAG_WIZPASS);
                CLEAR_FLAG (op, FLAG_WIZCAST);
              }
            break;

          case KW_friendly:
            if (thawer.get_sint32 ())
              if (op->type != PLAYER)
                add_friendly_object (op);

            break;

          case KW_monster:              GET_FLAG (op, FLAG_MONSTER); break;
          case KW_neutral:              GET_FLAG (op, FLAG_NEUTRAL); break;
          case KW_no_attack:            GET_FLAG (op, FLAG_NO_ATTACK); break;
          case KW_no_damage:            GET_FLAG (op, FLAG_NO_DAMAGE); break;
          case KW_obj_original:         GET_FLAG (op, FLAG_OBJ_ORIGINAL); break;
          case KW_generator:            GET_FLAG (op, FLAG_GENERATOR); break;
          case KW_use_content_on_gen:   GET_FLAG (op, FLAG_CONTENT_ON_GEN); break;
          case KW_is_thrown:            GET_FLAG (op, FLAG_IS_THROWN); break;
          case KW_auto_apply:           GET_FLAG (op, FLAG_AUTO_APPLY); break;
          case KW_see_invisible:        GET_FLAG (op, FLAG_SEE_INVISIBLE); break;
          case KW_can_roll:             GET_FLAG (op, FLAG_CAN_ROLL); break;
          case KW_overlay_floor:        GET_FLAG (op, FLAG_OVERLAY_FLOOR); break;
          case KW_is_turnable:          GET_FLAG (op, FLAG_IS_TURNABLE); break;
          case KW_is_used_up:           GET_FLAG (op, FLAG_IS_USED_UP); break;
          case KW_alive:                GET_FLAG (op, FLAG_ALIVE); break;
          case KW_applied:              GET_FLAG (op, FLAG_APPLIED); break;
          case KW_unpaid:               GET_FLAG (op, FLAG_UNPAID); break;
          case KW_is_animated:          GET_FLAG (op, FLAG_ANIMATE); break;
          case KW_no_pick:              GET_FLAG (op, FLAG_NO_PICK); break;
          case KW_reflecting:           GET_FLAG (op, FLAG_REFLECTING); break;
          case KW_changing:             GET_FLAG (op, FLAG_CHANGING); break;
          case KW_splitting:            GET_FLAG (op, FLAG_SPLITTING); break;
          case KW_hitback:              GET_FLAG (op, FLAG_HITBACK); break;
          case KW_startequip:           GET_FLAG (op, FLAG_STARTEQUIP); break;
          case KW_blocksview:           GET_FLAG (op, FLAG_BLOCKSVIEW); break;
          case KW_undead:               GET_FLAG (op, FLAG_UNDEAD); break;
          case KW_scared:               GET_FLAG (op, FLAG_SCARED); break;
          case KW_unaggressive:         GET_FLAG (op, FLAG_UNAGGRESSIVE); break;
          case KW_reflect_missile:      GET_FLAG (op, FLAG_REFL_MISSILE); break;
          case KW_reflect_spell:        GET_FLAG (op, FLAG_REFL_SPELL); break;
          case KW_no_magic:             GET_FLAG (op, FLAG_NO_MAGIC); break;
          case KW_no_drop:              GET_FLAG (op, FLAG_NO_DROP); break;
          case KW_random_movement:      GET_FLAG (op, FLAG_RANDOM_MOVE); break;
          case KW_was_wiz:              GET_FLAG (op, FLAG_WAS_WIZ); break;
          case KW_no_fix_player:        GET_FLAG (op, FLAG_NO_FIX_PLAYER); break;
          case KW_is_lightable:         GET_FLAG (op, FLAG_IS_LIGHTABLE); break;
          case KW_tear_down:            GET_FLAG (op, FLAG_TEAR_DOWN); break;
          case KW_can_use_shield:       GET_FLAG (op, FLAG_USE_SHIELD); break;
          case KW_can_cast_spell:       GET_FLAG (op, FLAG_CAST_SPELL); break;
          case KW_can_use_scroll:       GET_FLAG (op, FLAG_USE_SCROLL); break;
          case KW_can_use_range:        GET_FLAG (op, FLAG_USE_RANGE); break;
          case KW_can_use_bow:          GET_FLAG (op, FLAG_USE_BOW); break;
          case KW_can_use_armour:       GET_FLAG (op, FLAG_USE_ARMOUR); break;
          case KW_can_use_weapon:       GET_FLAG (op, FLAG_USE_WEAPON); break;
          case KW_can_use_ring:         GET_FLAG (op, FLAG_USE_RING); break;
          case KW_has_ready_bow:        GET_FLAG (op, FLAG_READY_BOW); break;
          case KW_has_ready_range:      GET_FLAG (op, FLAG_READY_RANGE); break;
          case KW_xrays:                GET_FLAG (op, FLAG_XRAYS); break;
          case KW_is_floor:             GET_FLAG (op, FLAG_IS_FLOOR); break;
          case KW_lifesave:             GET_FLAG (op, FLAG_LIFESAVE); break;
          case KW_no_strength:          GET_FLAG (op, FLAG_NO_STRENGTH); break;
          case KW_sleep:                GET_FLAG (op, FLAG_SLEEP); break;
          case KW_stand_still:          GET_FLAG (op, FLAG_STAND_STILL); break;
          case KW_random_move:          GET_FLAG (op, FLAG_RANDOM_MOVE); break;
          case KW_only_attack:          GET_FLAG (op, FLAG_ONLY_ATTACK); break;
          case KW_activate_on_push:     GET_FLAG (op, FLAG_ACTIVATE_ON_PUSH); break;
          case KW_activate_on_release:  GET_FLAG (op, FLAG_ACTIVATE_ON_RELEASE); break;
          case KW_confused:             GET_FLAG (op, FLAG_CONFUSED); break;
          case KW_stealth:              GET_FLAG (op, FLAG_STEALTH); break;
          case KW_cursed:               GET_FLAG (op, FLAG_CURSED); break;
          case KW_damned:               GET_FLAG (op, FLAG_DAMNED); break;
          case KW_see_anywhere:         GET_FLAG (op, FLAG_SEE_ANYWHERE); break;
          case KW_known_magical:        GET_FLAG (op, FLAG_KNOWN_MAGICAL); break;
          case KW_known_cursed:         GET_FLAG (op, FLAG_KNOWN_CURSED); break;
          case KW_can_use_skill:        GET_FLAG (op, FLAG_CAN_USE_SKILL); break;
          case KW_been_applied:         GET_FLAG (op, FLAG_BEEN_APPLIED); break;
          case KW_has_ready_scroll:     GET_FLAG (op, FLAG_READY_SCROLL); break;
          case KW_can_use_rod:          GET_FLAG (op, FLAG_USE_ROD); break;
          case KW_can_use_horn:         GET_FLAG (op, FLAG_USE_HORN); break;
          case KW_unique:               GET_FLAG (op, FLAG_UNIQUE); break;
          case KW_make_invisible:       GET_FLAG (op, FLAG_MAKE_INVIS); break;
          case KW_inv_locked:           GET_FLAG (op, FLAG_INV_LOCKED); break;
          case KW_is_wooded:            GET_FLAG (op, FLAG_IS_WOODED); break;
          case KW_is_hilly:             GET_FLAG (op, FLAG_IS_HILLY); break;
          case KW_is_water:             GET_FLAG (op, FLAG_IS_WATER); break;
          case KW_has_ready_skill:      GET_FLAG (op, FLAG_READY_SKILL); break;
          case KW_has_ready_weapon:     GET_FLAG (op, FLAG_READY_WEAPON); break;
          case KW_no_skill_ident:       GET_FLAG (op, FLAG_NO_SKILL_IDENT); break;
          case KW_is_blind:             GET_FLAG (op, FLAG_BLIND); break;
          case KW_can_see_in_dark:      GET_FLAG (op, FLAG_SEE_IN_DARK); break;
          case KW_is_cauldron:          GET_FLAG (op, FLAG_IS_CAULDRON); break;
          case KW_no_steal:             GET_FLAG (op, FLAG_NO_STEAL); break;
          case KW_one_hit:              GET_FLAG (op, FLAG_ONE_HIT); break;
          case KW_berserk:              GET_FLAG (op, FLAG_BERSERK); break;
          case KW_is_buildable:         GET_FLAG (op, FLAG_IS_BUILDABLE); break;
          case KW_destroy_on_death:     GET_FLAG (op, FLAG_DESTROY_ON_DEATH); break;

          case KW_armour:               thawer.get (op->resist[ATNR_PHYSICAL]); break;
          case KW_resist_physical:      thawer.get (op->resist[ATNR_PHYSICAL]); break;
          case KW_resist_magic:         thawer.get (op->resist[ATNR_MAGIC]); break;
          case KW_resist_fire:          thawer.get (op->resist[ATNR_FIRE]); break;
          case KW_resist_electricity:   thawer.get (op->resist[ATNR_ELECTRICITY]); break;
          case KW_resist_cold:          thawer.get (op->resist[ATNR_COLD]); break;
          case KW_resist_confusion:     thawer.get (op->resist[ATNR_CONFUSION]); break;
          case KW_resist_acid:          thawer.get (op->resist[ATNR_ACID]); break;
          case KW_resist_drain:         thawer.get (op->resist[ATNR_DRAIN]); break;
          case KW_resist_weaponmagic:   thawer.get (op->resist[ATNR_WEAPONMAGIC]); break;
          case KW_resist_ghosthit:      thawer.get (op->resist[ATNR_GHOSTHIT]); break;
          case KW_resist_poison:        thawer.get (op->resist[ATNR_POISON]); break;
          case KW_resist_slow:          thawer.get (op->resist[ATNR_SLOW]); break;
          case KW_resist_paralyze:      thawer.get (op->resist[ATNR_PARALYZE]); break;
          case KW_resist_turn_undead:   thawer.get (op->resist[ATNR_TURN_UNDEAD]); break;
          case KW_resist_fear:          thawer.get (op->resist[ATNR_FEAR]); break;
          case KW_resist_cancellation:  thawer.get (op->resist[ATNR_CANCELLATION]); break;
          case KW_resist_deplete:       thawer.get (op->resist[ATNR_DEPLETE]); break;
          case KW_resist_death:         thawer.get (op->resist[ATNR_DEATH]); break;
          case KW_resist_chaos:         thawer.get (op->resist[ATNR_CHAOS]); break;
          case KW_resist_counterspell:  thawer.get (op->resist[ATNR_COUNTERSPELL]); break;
          case KW_resist_godpower:      thawer.get (op->resist[ATNR_GODPOWER]); break;
          case KW_resist_holyword:      thawer.get (op->resist[ATNR_HOLYWORD]); break;
          case KW_resist_blind:         thawer.get (op->resist[ATNR_BLIND]); break;
          case KW_resist_internal:      thawer.get (op->resist[ATNR_INTERNAL]); break;
          case KW_resist_life_stealing: thawer.get (op->resist[ATNR_LIFE_STEALING]); break;
          case KW_resist_disease:       thawer.get (op->resist[ATNR_DISEASE]); break;

          case KW_luck:                 thawer.get (op->stats.luck); break;
          case KW_run_away:             thawer.get (op->run_away); break;
          case KW_pick_up:              thawer.get (op->pick_up); break;
          case KW_item_power:           thawer.get (op->item_power); break;
          case KW_gen_sp_armour:        thawer.get (op->gen_sp_armour); break;
          case KW_anim_speed:           thawer.get (op->anim_speed); break;
          case KW_container:            thawer.get (op->weight_limit); break;
          case KW_will_apply:           thawer.get (op->will_apply); break;
          case KW_attack_movement:      thawer.get (op->attack_movement); break;
          case KW_move_state:           thawer.get (op->move_status); break;
          case KW_expmul:               thawer.get (op->expmul); break;
          case KW_glow_radius:          thawer.get (op->glow_radius); break;
          case KW_weapontype:           thawer.get (op->weapontype); break;
          case KW_tooltype:             thawer.get (op->tooltype); break;
          case KW_casting_time:         thawer.get (op->casting_time); break;
          case KW_elevation:            thawer.get (op->elevation); break;
          case KW_smoothlevel:          thawer.get (op->smoothlevel); break;
          case KW_client_type:          thawer.get (op->client_type); break;
          case KW_duration:             thawer.get (op->duration); break;
          case KW_range:                thawer.get (op->range); break;
          case KW_range_modifier:       thawer.get (op->range_modifier); break;
          case KW_dam_modifier:         thawer.get (op->dam_modifier); break;
          case KW_duration_modifier:    thawer.get (op->duration_modifier); break;

            //TODO: mechanism to ensure that KW_xxx is consecutive needed from include/preprocess
            //TODO: parse from other include files
          case KW_body_range:           thawer.get (op->body_info[0]); break;
          case KW_body_arm:             thawer.get (op->body_info[1]); break;
          case KW_body_torso:           thawer.get (op->body_info[2]); break;
          case KW_body_head:            thawer.get (op->body_info[3]); break;
          case KW_body_neck:            thawer.get (op->body_info[4]); break;
          case KW_body_skill:           thawer.get (op->body_info[5]); break;
          case KW_body_finger:          thawer.get (op->body_info[6]); break;
          case KW_body_shoulder:        thawer.get (op->body_info[7]); break;
          case KW_body_foot:            thawer.get (op->body_info[8]); break;
          case KW_body_hand:            thawer.get (op->body_info[9]); break;
          case KW_body_wrist:           thawer.get (op->body_info[10]); break;
          case KW_body_waist:           thawer.get (op->body_info[11]); break;
          case KW_can_apply:
            break;

          case KW_connected:
            add_button_link (op, op->map, thawer.get_sint32 ());
            break;

          case KW_randomitems:
            op->randomitems = find_treasurelist (thawer.get_str ());
            //if (!op->randomitems)
            //  LOG (llevError, "%s uses unknown randomitems '%s'.\n", op->debug_desc (), thawer.get_str ());
            break;

          case KW_msg:
            thawer.get_ml (KW_endmsg, op->msg);
            //TODO: allow longer messages
            if (strlen (op->msg) >= HUGE_BUF)
              {
                LOG (llevDebug, "\tError message length >= %d: %d\n>%.80s<\n", HUGE_BUF, strlen (op->msg), &op->msg);
                op->msg = "ERROR, please report: string too long, winged.\n";
              }
            break;

          case KW_lore:
            thawer.get_ml (KW_endlore, op->lore);
            //TODO: allow longer messages
            /* Just print a warning so we can be reasonably safe
             * about not overflowing the buffer.
             */
            if (strlen (op->lore) > (HUGE_BUF / 2))
              LOG (llevDebug, "\tWarning lore length > %d (max allowed=%d): %d\n>%.80s<\n",
                   HUGE_BUF / 2, HUGE_BUF, strlen (op->lore), &op->lore);
            break;

          case KW_editable:
          case KW_editor_folder:
            break;

          case KW_More:      // uppercase alias
          case KW_more:
            /* We need to record that this is a multipart object,
             * so the calling function can glue things back together
             */
            ismore = 1;
            break;

          case KW_end:
            check_loaded_object (op);

            if (!arch_init)
              op->instantiate ();

            return ismore ? LL_MORE : LL_NORMAL;

          case KW_EOF:
            return LL_EOF;

          case KW_ERROR:
            set_ob_key_value (op, thawer.last_keyword, thawer.last_value, true);
            //fprintf (stderr, "addkv(%s,%s)\n", thawer.last_keyword, thawer.last_value);//D
            break;

          default:
            if (!thawer.parse_error (kw, "object", op->name))
              return false;
            break;
        }
    }
}

/*
 * Loads an object from the given file-pointer.
 * Variables will be read and parsed and patched into the object
 * until the string "end" is reached, or the end of the file.
 *
 * bufstat is used to determine various file attributes:
 *  LO_REPATE (0): We are reading from the same buffer as the last call.
 *  LO_LINEMODE (1): file that is being read from is multi purpose (ie, other functions
 *      will also be reading from this (treasure file, artifacts.)
 *  LO_NEWFILE (2): This is the first read from a particular file, so the buffers should
 *      be reset.
 *  LO_NOREAD (3): Reset the buffers, but don't read from it. (op can be null)
 *
 */
int
load_object (object_thawer &fp, object *op, int map_flags)
{
  coroapi::cede_every (1000); // cede once in a while

  return parse_object (op, fp, map_flags);
}

/* This takes a buffer, scans it for variables, and sets those variables
 * as appropriate in op.
 *
 * This function appears to be used in only 2 places - in crossedit to
 * override values and in c_wiz to mutate values.
 */
int
set_variable (object *op, char *buf)
{
  object_thawer thawer (buf, (AV *)0);

  return parse_object (op, thawer, 0);
}

/*
 * Initialises the array of variable-names.  Needed before any
 * objects can be loaded.  Called by init_library().
 */

void
init_vars ()
{
}

/* This returns a string of the integer movement type */
#if 0
// unused function
static char *
get_string_move_type (MoveType mt)
{
  static char retbuf[MAX_BUF], retbuf_all[MAX_BUF];
  int i, all_count = 0, count;

  strcpy (retbuf, "");
  strcpy (retbuf_all, " all");

  /* Quick check, and probably fairly common */
  if (mt == MOVE_ALL)
    return retbuf_all + 1;
  if (mt == 0)
    {
      strcpy (retbuf, "0");
      return retbuf;
    }

  /* We basically slide the bits down.  Why look at MOVE_ALL?
   * because we may want to return a string like 'all -swim',
   * and if we just looked at mt, we couldn't get that.
   */
  for (i = MOVE_ALL, count = 0; i != 0; i >>= 1, count++)
    {
      if (mt & (1 << count))
        {
          strcat (retbuf, " ");
          strcat (retbuf, move_name[count]);
        }
      else
        {
          strcat (retbuf_all, " -");
          strcat (retbuf_all, move_name[count]);
          all_count++;
        }
    }
  /* Basically, if there is a single negation, return it, eg
   * 'all -swim'.  But more than that, just return the
   * enumerated values.  It doesn't make sense to return
   * 'all -walk -fly_low' - it is shorter to return 'fly_high swim'
   */
  if (all_count <= 1)
    return retbuf_all + 1;
  else
    return retbuf + 1;
}
#endif

// compare *op against *tmp and output differences
void
put (object_freezer &f, object *op, object *tmp)
{
  static const keyword resist_save[NROFATTACKS] = {
#  define def(uc, lc, name, plus, change) KW_resist_ ## lc,
#   include "attackinc.h"
#  undef def
  };

  /* This is a list of keywords that correspond to the FLAG_.. values.
   * This is a simple 1:1 mapping - if FLAG_FRIENDLY is 15, then
   * the 15'th element of this array should match that name.
   * If an entry is NULL, that is a flag not to loaded/saved.
   */
  static const keyword flag_names [NUM_FLAGS] = {
    KW_alive,
    KW_wiz,
    KW_NULL,
    KW_NULL,
    KW_was_wiz,
    KW_applied,
    KW_unpaid,
    KW_can_use_shield,
    KW_no_pick,
    KW_NULL, // walk_on
    KW_NULL, // no_pass
    /* 10 */
    KW_is_animated,
    KW_NULL, // slow_move
    KW_NULL, // flying
    KW_monster,
    KW_friendly,
    KW_generator,
    KW_is_thrown,
    KW_auto_apply,
    KW_NULL, // was KW_treasure
    KW_player_sold,
    /* 20 */
    KW_see_invisible,
    KW_can_roll,
    KW_overlay_floor,
    KW_is_turnable,
    KW_NULL, // walk_off
    KW_NULL, // fly_on
    KW_NULL, // fly_off
    KW_is_used_up,
    KW_identified,
    KW_reflecting,
    /* 30 */
    KW_changing,
    KW_splitting,
    KW_hitback,
    KW_startequip,
    KW_blocksview,
    KW_undead,
    KW_scared,
    KW_unaggressive,
    KW_reflect_missile,
    KW_reflect_spell,
    /* 40 */
    KW_no_magic,
    KW_no_fix_player,
    KW_is_lightable,
    KW_tear_down,
    KW_run_away,
    KW_NULL, // pass_thru
    KW_NULL, // an_pass_thru
    KW_pick_up,
    KW_unique,
    KW_no_drop,
    /* 50 */
    KW_NULL, // wizcast
    KW_can_cast_spell,
    KW_can_use_scroll,
    KW_can_use_range,
    KW_can_use_bow,
    KW_can_use_armour,
    KW_can_use_weapon,
    KW_can_use_ring,
    KW_has_ready_range,
    KW_has_ready_bow,
    /* 60 */
    KW_xrays,
    KW_NULL,
    KW_is_floor,
    KW_lifesave,
    KW_no_strength,
    KW_sleep,
    KW_stand_still,
    KW_random_move,
    KW_only_attack,
    KW_confused,
    /* 70 */
    KW_stealth,
    KW_NULL,
    KW_NULL,
    KW_cursed,
    KW_damned,
    KW_see_anywhere,
    KW_known_magical,
    KW_known_cursed,
    KW_can_use_skill,
    KW_been_applied,
    /* 80 */
    KW_has_ready_scroll,
    KW_can_use_rod,
    KW_NULL,
    KW_can_use_horn,
    KW_make_invisible,
    KW_inv_locked,
    KW_is_wooded,
    KW_is_hilly,
    KW_has_ready_skill,
    KW_has_ready_weapon,
    /* 90 */
    KW_no_skill_ident,
    KW_is_blind,
    KW_can_see_in_dark,
    KW_is_cauldron,
    KW_NULL,
    KW_no_steal,
    KW_one_hit,
    KW_NULL,
    KW_berserk,
    KW_neutral,
    /* 100 */
    KW_no_attack,
    KW_no_damage,
    KW_obj_original,
    KW_NULL,
    KW_activate_on_push,
    KW_activate_on_release,
    KW_is_water,
    KW_use_content_on_gen,
    KW_NULL,
    KW_is_buildable,
    /* 110 */
    KW_destroy_on_death,
    KW_NULL,
  };

  int i;

  /* This saves the key/value lists.  We do it first so that any
   * keys that match field names will be overwritten by the loader.
   */
  for (key_value *my_field = op->key_values; my_field; my_field = my_field->next)
    {
      /* Find the field in the opposing member. */
      key_value *arch_field = get_ob_key_link (tmp, my_field->key);

      /* If there's no partnering field, or it's got a different value, save our field. */
      if (!arch_field || my_field->value != arch_field->value)
        f.put (my_field->key, my_field->value);
    }

  /* We don't need to worry about the arch's extra fields - they
   * will get taken care of the copy_to method.
   */

  {
    char uids[64];
    snprintf (uids, sizeof (uids), "<1.%llx>", (unsigned long long)op->uuid.seq);
    f.put (KW_uuid, (const char *)uids);
  }

#define CMP_OUT(v)    if (op->v != tmp->v) f.put (KW_ ## v, op->v)
#define CMP_OUT2(k,v) if (op->v != tmp->v) f.put (KW_ ## k, op->v)

  CMP_OUT (name);
  CMP_OUT (name_pl);
  CMP_OUT (custom_name);
  CMP_OUT (title);
  CMP_OUT (race);
  CMP_OUT (slaying);

  if (op->msg != tmp->msg)
    f.put (KW_msg, KW_endmsg, op->msg);
  if (op->lore != tmp->lore)
    f.put (KW_lore, KW_endlore, op->lore);

  CMP_OUT (other_arch);
  CMP_OUT (face);

  if (op->animation_id != tmp->animation_id)
    if (op->animation_id)
      {
        f.put (KW_animation, animations[GET_ANIM_ID (op)].name);

        if (!QUERY_FLAG (op, FLAG_ANIMATE))
          f.put (KW_is_animated, (sint32) 0);
      }
    else
      f.put (KW_animation, (const char *) 0);

  CMP_OUT2 (str, stats.Str);
  CMP_OUT2 (dex, stats.Dex);
  CMP_OUT2 (con, stats.Con);
  CMP_OUT2 (wis, stats.Wis);
  CMP_OUT2 (pow, stats.Pow);
  CMP_OUT2 (cha, stats.Cha);
  CMP_OUT2 (int, stats.Int);

  CMP_OUT2 (hp, stats.hp);
  CMP_OUT2 (maxhp, stats.maxhp);
  CMP_OUT2 (sp, stats.sp);
  CMP_OUT2 (maxsp, stats.maxsp);
  CMP_OUT2 (grace, stats.grace);
  CMP_OUT2 (maxgrace, stats.maxgrace);
  CMP_OUT2 (exp, stats.exp);

  CMP_OUT (perm_exp);
  CMP_OUT (expmul);

  CMP_OUT2 (food, stats.food);
  CMP_OUT2 (dam, stats.dam);
  CMP_OUT2 (luck, stats.luck);
  CMP_OUT2 (wc, stats.wc);
  CMP_OUT2 (ac, stats.ac);

  CMP_OUT (x);
  CMP_OUT (y);
  CMP_OUT (speed);
  CMP_OUT (speed_left);
  CMP_OUT2 (move_state, move_status);
  CMP_OUT (attack_movement);
  CMP_OUT (nrof);
  CMP_OUT (level);
  CMP_OUT (direction);
  CMP_OUT (type);
  CMP_OUT (subtype);
  CMP_OUT (attacktype);

  for (i = 0; i < NROFATTACKS; i++)
    if (op->resist[i] != tmp->resist[i])
      f.put (resist_save[i], op->resist[i]);

  CMP_OUT (path_attuned);
  CMP_OUT (path_repelled);
  CMP_OUT (path_denied);
  CMP_OUT2 (material, materials);//TODO: nuke
  CMP_OUT (materialname);
  CMP_OUT (value);
  CMP_OUT (carrying);
  CMP_OUT (weight);
  CMP_OUT (invisible);
  CMP_OUT (state);
  CMP_OUT (magic);
  CMP_OUT (last_heal);
  CMP_OUT (last_sp);
  CMP_OUT (last_grace);
  CMP_OUT (last_eat);
  CMP_OUT (glow_radius);

  if (QUERY_FLAG (op, FLAG_IS_LINKED) && (i = get_button_value (op)))
    f.put (KW_connected, i);

  CMP_OUT (randomitems);
  CMP_OUT2 (container, weight_limit);

  CMP_OUT (run_away);
  CMP_OUT (pick_up);
  CMP_OUT (will_apply);
  CMP_OUT (smoothlevel);
  CMP_OUT (weapontype);
  CMP_OUT (tooltype);
  CMP_OUT (elevation);
  CMP_OUT (client_type);
  CMP_OUT (item_power);
  CMP_OUT (duration);
  CMP_OUT (range);
  CMP_OUT (range_modifier);
  CMP_OUT (duration_modifier);
  CMP_OUT (dam_modifier);
  CMP_OUT (gen_sp_armour);

  CMP_OUT (move_type);
  CMP_OUT (move_block);
  CMP_OUT (move_allow);
  CMP_OUT (move_on);
  CMP_OUT (move_off);
  CMP_OUT (move_slow);
  CMP_OUT (move_slow_penalty);

  if (op->flag != tmp->flag)
    for (i = 0; i <= NUM_FLAGS; i++)
      if (flag_names [i] && op->flag [i] != tmp->flag [i])
        f.put (flag_names [i], op->flag [i] ? "1" : "0");

  /* Save body locations */
  for (i = 0; i < NUM_BODY_LOCATIONS; i++)
    if (op->body_info[i] != tmp->body_info[i])
      f.put (body_locations[i].save_name, op->body_info[i]);
}

/*
 * Dumps all variables in an object to a file.
 * If bit 0 of flag is set, unpaid objects will be saved.  As of now,
 * the only place this is not set is when saving the player.
 */
void
save_object (object_freezer &fp, object *op, int flag)
{
  /* Even if the object does have an owner, it would seem that we should
   * still save it.
   */
  if (op->owner)
    return;

  /* If it is unpaid and we don't want to save those, just return. */
  if (!(flag & 1) && op->flag [FLAG_UNPAID])
    return;

  archetype *at = op->arch ? (archetype *)op->arch : empty_archetype;

  fp.put (KW_arch, at->name);
  put (fp, op, &at->clone);

  /* Eneq(@csd.uu.se): Added this to allow containers being saved with contents */

  for (object *tmp = op->inv; tmp; tmp = tmp->below)
    save_object (fp, tmp, flag);

  fp.put (op);
  fp.put (KW_end);
}

Revision:	1.56
Committed:	Fri Feb 9 01:52:10 2007 UTC (17 years, 3 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.55:	+5 -8 lines
Log Message:	minor stuff, indent