server/common/loader.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 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 Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

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

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

extern archetype *loading_arch;

//+GPL

/* 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 */
  "spell_summon_devil",         /* 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
};

/* 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.
 */
void
object::post_load_check ()
{
  if (type >= NUM_TYPES)
    {
      LOG (llevError, "ITEMBUG: %s: type out of range, resetting to 0.\n", debug_desc ());
      type = 0;
    }

  switch (type)
    {
      case RANGED:
      case BOW:
      case WAND:
      case ROD:
      case HORN:
        if (slot [body_range].info != -1)
          {
            LOG (llevError, "ITEMBUG: %s: body_range %d != -1\n", debug_desc (), slot [body_range].info);
            slot [body_range].info = -1;
          }
        break;

      case WEAPON:
        if (slot [body_combat].info != -1)
          {
            LOG (llevError, "ITEMBUG: %s: body_combat %d != -1\n", debug_desc (), slot [body_combat].info);
            slot [body_combat].info = -1;
          }
        break;

      case SHIELD:
        if (slot [body_shield].info != -1)
          {
            LOG (llevError, "ITEMBUG: %s: body_shield %d != -1\n", debug_desc (), slot [body_shield].info);
            slot [body_shield].info = -1;
          }
        break;

      case PLAYER:
        if (slot [body_shield].info != 1)
          {
            LOG (llevError, "ITEMBUG: %s: body_shield %d != 1\n", debug_desc (), slot [body_shield].info);
            slot [body_shield].info = 1;
          }

        if (slot [body_combat].info != 1)
          {
            LOG (llevError, "ITEMBUG: %s: body_combat %d != 1\n", debug_desc (), slot [body_combat].info);
            slot [body_combat].info = 1;
          }

        if (slot [body_range].info != 1)
          {
            LOG (llevError, "ITEMBUG: %s: body_range %d != 1\n", debug_desc (), slot [body_range].info);
            slot [body_range].info = 1;
          }
        break;
    }

  /* 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 (arch && name != arch->object::name && name_pl == arch->object::name_pl)
    name_pl = 0;

  if (!name_pl)
    name_pl = name;

  /* objects now have a materialname.  try to patch it in */
  if (material == MATERIAL_NULL && !(is_weapon () && level > 0))
    select_material (this, map ? map->difficulty : 5);

  if (speed < 0.)
    {
      flag [FLAG_RANDOM_SPEED] = true;
      speed = -speed;
      // speed_left will be randomised in instantiate () and copy_to ()
    }

  /* 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 (loading_arch && (type == WEAPON || type == BOW || type == ROD || type == HORN || type == WAND))
    {
      if (!skill)
        LOG (llevError, "ITEMBUG: weapon %s lacks a skill.\n", debug_desc ());
      else if ((skill == shstr_one_handed_weapons && slot[body_arm].info != -1) ||
               (skill == shstr_two_handed_weapons && slot[body_arm].info != -2))
        LOG (llevError, "ITEMBUG: weapon %s arm usage does not match skill: %d, %s\n", debug_desc (), slot[body_arm].info, &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 (type == WEAPON
      || type == ARMOUR  || type == HELMET
      || type == SHIELD  || type == RING
      || type == BOOTS   || type == GLOVES
      || type == AMULET  || type == GIRDLE
      || type == BRACERS || type == CLOAK)
    {
      if (last_heal)
        {
          LOG (llevError, "ITEMBUG: object %s still has last_heal set, not gen_sp_armour\n", debug_desc ());
          gen_sp_armour = last_heal;
          last_heal = 0;
        }

      int ip = calc_item_power (this, 0);

      /* Legacy objects from before item power was in the game */
      if (!item_power && ip)
        {
          if (ip > 3)
            LOG (llevDebug, "ITEMBUG: Object %s had no item power, using %d\n", debug_desc (), ip);

          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 0 //TODO
      if (ip > 2 * item_power && ip > (item_power + 3))
        LOG (llevDebug, "Object %s seems to have too low item power? %d > %d\n", debug_desc (), ip, item_power);
#endif
    }

  /* old style spellcasting object (pretty common) - need to load in the appropriate object */
  /* (schmorp) old really doesn't mean old, imho, just a more compact way to store such objects */
  if ((type == ROD
       || type == WAND
       || type == SCROLL
       || type == HORN
       || type == FIREWALL
       /* POTIONS and ALTARS don't always cast spells, but if they do, update them */
       || ((type == POTION || type == ALTAR) && stats.sp)) // watchout: sp = 0 is still magic bullet.
      && !inv
      && !loading_arch
      && stats.sp)     // watchout: old magic bullet stuff directly on the map is going to break here!
                       // TODO: at least one watchout-comments is redundant - investigate/remove
    {
      // TODO: fix firewall object on map
      /* Firewall is bizarre in that spell type was stored in dam. Rest are 'normal'
       * in that spell was stored in sp.
       */
      //LOG (llevError, "old spellcasting object found: %s", debug_desc ());
      object *tmp = archetype::get (spell_mapping[type == FIREWALL ? stats.dam : stats.sp]);
      insert_ob_in_ob (tmp, this);
      randomitems = 0;
    }

  /* spellbooks & runes use slaying.  But not to arch name, but to spell name */
  if ((type == SPELLBOOK || type == RUNE) && slaying && !inv && !loading_arch)
    {
      LOG (llevError, "ITEMBUG: spellbook/rune found without inv but slaying: %s", debug_desc ());
      object *tmp = get_archetype_by_object_name (slaying);
      insert_ob_in_ob (tmp, this);
      randomitems = 0;   /* So another spell isn't created for this object */
      /* without this, value is all screwed up */
      value = arch->value * inv->value;
    }

  if (this->flag [FLAG_MONSTER])
    {
      if (stats.hp > stats.maxhp)
        {
          LOG (llevInfo, "ITEMBUG: monster %s has hp set higher than maxhp (%d>%d)\n", debug_desc (), stats.hp, stats.maxhp);
          stats.maxhp = stats.hp;
        }

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

  if ((this->flag [FLAG_GENERATOR] && this->flag [FLAG_CONTENT_ON_GEN]) || type == CREATOR || 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!)
     */
    /* ??? this *should* be done elsewhere, e.g. after map loading etc. */
    flag_inv (this, 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 (type == PLAYERMOVER)
    {
      if (!move_type)
        {
          if (stats.maxhp)
            {
              move_type = MOVE_ALL;
              stats.maxhp = 0;
            }
          else
            move_type = MOVE_WALK;
        }
    }

  // if the object has an animation, try to provide a default face
  if (has_anim ())
    {
      const animation &anim_ob = anim ();

      if (anim_speed)
        // if this item is time-animated, force the last frame
        animate_object (this, 0);
      else if (flag [FLAG_MONSTER])
        // if it is a monster, set appropriate facing
        animate_object (this, direction);
    }
}

static void
set_move (MoveType &mt, object_thawer &f)
{
  static const struct flagstr {
    const char *name;
    MoveType flags;
  } move_flags[] = {
    { "walk"    , MOVE_WALK },
    { "flying"  , MOVE_FLY_LOW | MOVE_FLY_HIGH },
    { "fly_low" , MOVE_FLY_LOW },
    { "fly_high", MOVE_FLY_HIGH },
    { "swim"    , MOVE_SWIM },
    { "boat"    , MOVE_BOAT },
    { "ship"    , MOVE_SHIP },
    { "all"     , MOVE_ALL },
  };

  const char *str = f.get_str ();

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

  mt = 0;

  for (str = strtok ((char *)str, " "); str; str = strtok (0, " "))
    {
      bool negate = 0;

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

      for (const flagstr *f = move_flags; f < move_flags + array_length (move_flags); ++f)
        {
          if (!strcmp (f->name, str))
            {
              if (negate)
                mt &= ~f->flags;
              else
                mt |=  f->flags;

              goto next;
            }
        }

      LOG (llevError, "common/loader.C: set_move - unknown move string '%s'\n", str);

next: ;
    }
}

//-GPL

#define GET_FLAG(op,flg) op->flag [flg] = f.get_bool ()

bool
object::parse_kv (object_thawer &f)
{
  object *op_inv = inv;
  key_value *last_kv = kv.first;

  for (;;)
    {
      switch (f.kw)
        {
          case KW_uuid:
            if (!uuid.parse (f.get_str ()))
              {
                f.parse_warn ("unparseable uuid");
                uuid = UUID::gen ();
              }
            break;

          case KW_oid:
            f.get (this, f.get_sint32 ());
            break;

          case KW_name:         f.get (name); break;
          case KW_name_pl:      f.get (name_pl); break;
          case KW_title:        f.get (title); break;
          case KW_custom_name:  f.get (custom_name); break;

          case KW_attach:       f.get_ornull (attach); break;
          case KW_skill:        f.get_ornull (skill); break;
          case KW_race:         f.get_ornull (race); break;
          case KW_slaying:      f.get_ornull (slaying); break;
          case KW_tag:          f.get_ornull (tag); break;

          case KW_arch:
            if (object *tmp = object::read (f))
              {
                tmp->deactivate ();

                // 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.
                // and finally we do not want any funny effects
                tmp->clr_flag (FLAG_OBJ_ORIGINAL);
                tmp->clr_flag (FLAG_REMOVED);

                if (!op_inv)
                  {
                    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 = this;
                op_inv = tmp;
              }
            else
              LOG (llevError, "ERROR: couldn't load inventory object, file corrupted?\n");

            continue;

          case KW_other_arch:
            if (loading_arch == this)
              archetype::postpone_arch_ref (loading_arch->other_arch, f.get_str ());
            else
              {
                other_arch = archetype::find (f.get_str ());

                if (!other_arch)
                  f.parse_warn (format ("%s uses unknown other_arch '%s'.\n", debug_desc (), f.get_str ()));
              }
            break;

          case KW_owner:
            f.delayed_deref (this, owner, f.get_str ());
            break;

          case KW_animation:
            {
              this->clr_flag (FLAG_ANIMATE);
              animation_id = 0;

              if (f.has_value () && (animation_id = find_animation (f.get_str ())))
                this->set_flag (FLAG_ANIMATE); //TODO: should not be forced to true here
            }
            break;

          case KW_last_heal:  f.get (last_heal);  break;
          case KW_last_sp:    f.get (last_sp);    break;
          case KW_last_grace: f.get (last_grace); break;
          case KW_last_eat:   f.get (last_eat);   break;
          case KW_sl:
          case KW_speed_left: f.get (speed_left); break;

          case KW_speed:
            f.get (speed);

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

            break;

          case KW_slow_move:
            move_slow |= MOVE_WALK;
            f.get (move_slow_penalty);
            break;

          case KW_face:
            face = f.has_value () ? face_find (f.get_str ()) : blank_face;
            break;

          case KW_sound:
            if (f.has_value ())
              {
                sound = sound_find (f.get_str ());
                if (!sound)
                  f.parse_warn (format ("sound '%s' not found", f.get_str ()));
              }
            else
              sound = 0;
            break;

          case KW_sound_destroy:
            if (f.has_value ())
              {
                sound_destroy = sound_find (f.get_str ());
                if (!sound_destroy)
                  f.parse_warn (format ("sound '%s' not found", f.get_str ()));
              }
            else
              sound_destroy = 0;
            break;

          case KW_x: f.get (x); break;
          case KW_y: f.get (y); break;

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

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

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

            /* These are the new values */
          case KW_move_block:           set_move (move_block, f); break;
          case KW_move_allow:           set_move (move_allow, f); break;
          case KW_move_type:            set_move (move_type , f); break;
          case KW_move_on:              set_move (move_on   , f); break;
          case KW_move_off:             set_move (move_off  , f); break;
          case KW_move_slow:            set_move (move_slow , f); break;

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

            break;

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

            break;

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

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

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

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

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


          case KW_identified:
            GET_FLAG (this, FLAG_IDENTIFIED);
            //TODO: move to check_object or so
            if (this->flag [FLAG_IDENTIFIED])
              this->clr_flag (FLAG_KNOWN_MAGICAL);

            break;

          case KW_friendly:
            if (f.get_bool ())
              if (type != PLAYER)
                add_friendly_object (this);

            break;

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

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

          case KW_luck:                 f.get (stats.luck); break;
          case KW_run_away:             f.get (run_away); break;
          case KW_pick_up:              f.get (pick_up); break;
          case KW_item_power:           f.get (item_power); break;
          case KW_gen_sp_armour:        f.get (gen_sp_armour); break;
          case KW_anim_speed:           f.get (anim_speed); break;
          case KW_container:            f.get (weight_limit); break;
          case KW_will_apply:           f.get (will_apply); break;
          case KW_attack_movement:      f.get (attack_movement); break;
          case KW_move_state:           f.get (move_status); break;
          //case KW_expmul:               f.get (expmul); break;//D declared const for the time being
          case KW_glow_radius:          f.get (glow_radius); break;
          case KW_weapontype:           f.get (weapontype); break;
          case KW_casting_time:         f.get (casting_time); break;

          // elevation is deprecated
          case KW_elevation:            break;

          case KW_smoothlevel:          f.get (smoothlevel); smoothlevel = clamp (smoothlevel, 0, 255); break;
          case KW_client_type:          f.get (client_type); break;
          case KW_duration:             f.get (duration); break;
          case KW_range:                f.get (range); break;
          case KW_range_modifier:       f.get (range_modifier); break;
          case KW_dam_modifier:         f.get (dam_modifier); break;
          case KW_duration_modifier:    f.get (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:           slot[body_range]   .info = f.get_sint32 (); break;
          case KW_body_shield:          slot[body_shield]  .info = f.get_sint32 (); break;
          case KW_body_combat:          slot[body_combat]  .info = f.get_sint32 (); break;
          case KW_body_arm:             slot[body_arm]     .info = f.get_sint32 (); break;
          case KW_body_torso:           slot[body_torso]   .info = f.get_sint32 (); break;
          case KW_body_head:            slot[body_head]    .info = f.get_sint32 (); break;
          case KW_body_neck:            slot[body_neck]    .info = f.get_sint32 (); break;
          case KW_body_skill:           slot[body_skill]   .info = f.get_sint32 (); break;
          case KW_body_finger:          slot[body_finger]  .info = f.get_sint32 (); break;
          case KW_body_shoulder:        slot[body_shoulder].info = f.get_sint32 (); break;
          case KW_body_foot:            slot[body_foot]    .info = f.get_sint32 (); break;
          case KW_body_hand:            slot[body_hand]    .info = f.get_sint32 (); break;
          case KW_body_wrist:           slot[body_wrist]   .info = f.get_sint32 (); break;
          case KW_body_waist:           slot[body_waist]   .info = f.get_sint32 (); break;
          case KW_can_apply:
            break;

          case KW_connected:
            {
              shstr connected;

              f.get (connected);
              add_link (map, connected);
            }
            break;

          case KW_randomitems:
            if (f.has_value ())
              {
                randomitems =
                  loading_arch
                    ? treasurelist::get  (f.get_str ())
                    : treasurelist::find (f.get_str ());

                if (!randomitems)
                  {
                    LOG (llevError, "%s uses unknown randomitems '%s'.\n", debug_desc (), f.get_str ());
                    randomitems = treasurelist::get (shstr_none); // avoid crashes
                  }
              }
            else
              randomitems = 0;
            break;

          case KW_msg:
            f.get_ml (KW_endmsg, msg);
            break;

          case KW_lore:
            f.get_ml (KW_endlore, lore);
            break;

          case KW_editable:
          case KW_editor_folder:
            break;

          case KW_end:
            if (!loading_arch)
              instantiate ();

            f.next ();
            return true;

          case KW_ERROR:
            // we do not even try to find old values, duplicate keys stay duplicate
            // the list gets reversed after loading
            kv.add (shstr (f.kw_str), shstr (f.value));
            break;

          default:
            if (!f.parse_error ("object", name))
              return false;
            break;
        }

      f.next ();
    }
}

object *
object::read (object_thawer &f, maptile *map)
{
  assert (f.kw == KW_arch);

  archetype *arch = archetype::find (f.get_str ());

  if (!arch)
    {
      LOG (llevError, "object referring to nonexistent archetype '%s'.\n", f.get_str ());
      arch = archetype::find (shstr_earthwall);
    }

  assert (arch); //D maybe use exception handling of sorts?

  f.next ();

  object *op = arch->instance ();
  op->map = map;
  // instance() activates, this should be fixed properly
  op->deactivate ();

  if (!op->parse_kv (f))
    {
      op->destroy ();
      return  0;
    }

  // the loader reverses the ordering of kv-pairs, so we reverse it again after loading
  // that greatly simplifies the loading code.
  op->kv.reverse ();

  op->post_load_check ();
  return op;
}

/* 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 f (format ("%s\nend", buf), (AV *)0);

  return op->parse_kv (f);
}

// compare *op against *arch and output differences
static void
write_diff (object_freezer &f, object *op, object *arch)
{
  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_NULL,
    KW_NULL,
    KW_NULL,
    KW_NULL,
    KW_applied,
    KW_unpaid,
    KW_can_use_shield,
    KW_no_pick,
    KW_NULL, // walk_on
    /* 10 */
    KW_NULL, // no_pass
    KW_is_animated,
    KW_NULL, // slow_move
    KW_NULL, // flying
    KW_monster,
    KW_friendly,
    KW_generator,
    KW_is_thrown,
    KW_auto_apply,
    KW_treasure_env,
    /* 20 */
    KW_player_sold,
    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,
    /* 30 */
    KW_reflecting,
    KW_changing,
    KW_splitting,
    KW_hitback,
    KW_startequip,
    KW_blocksview,
    KW_undead,
    KW_scared,
    KW_unaggressive,
    KW_reflect_missile,
    /* 40 */
    KW_reflect_spell,
    KW_no_magic,
    KW_NULL,
    KW_is_lightable,
    KW_tear_down,
    KW_run_away,
    KW_NULL, // pass_thru
    KW_NULL, // an_pass_thru
    KW_pick_up,
    KW_unique,
    /* 50 */
    KW_no_drop,
    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,
    /* 60 */
    KW_has_ready_bow,
    KW_xrays,
    KW_NULL,
    KW_is_floor,
    KW_lifesave,
    KW_no_strength,
    KW_sleep,
    KW_stand_still,
    KW_random_move,
    KW_only_attack,
    /* 70 */
    KW_confused,
    KW_stealth,
    KW_NULL,
    KW_NULL,
    KW_cursed,
    KW_damned,
    KW_see_anywhere,
    KW_known_magical,
    KW_known_cursed,
    KW_can_use_skill,
    /* 80 */
    KW_been_applied,
    KW_has_ready_scroll,
    KW_can_use_rod,
    KW_precious,
    KW_can_use_horn,
    KW_make_invisible,
    KW_inv_locked,
    KW_is_wooded,
    KW_is_hilly,
    KW_has_ready_skill,
    /* 90 */
    KW_has_ready_weapon,
    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,
    /* 100 */
    KW_neutral,
    KW_no_attack,
    KW_no_damage,
    KW_obj_original,
    KW_random_speed,
    KW_activate_on_push,
    KW_activate_on_release,
    KW_is_water,
    KW_use_content_on_gen,
    KW_NULL,
    /* 110 */
    KW_is_buildable,
    KW_destroy_on_death,
    KW_NULL,
  };

  // obj_original is the only commonly differing flag between archetype
  // and object, so special-case it here to be able to skip the loop
  static const struct flagmask : object::flags_t
  {
    flagmask ()
    {
      for (int i = 0; i < NUM_FLAGS; i++)
        if (flag_names [i])
          set (i);
    }
  } flagmask;

  /* 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 *kv = op->kv.first; kv; kv = kv->next)
    if (arch->kv.empty () || arch->kv [kv->key] != kv->value)
      f.put (kv->key, kv->value);

  if (op->uuid)
    {
      // highly optimised - this is often 25% of all data written
      char *cur = f.force (sizeof ("uuid ") + UUID::MAX_LEN + 1);
      char *ptr = cur;

      memcpy (ptr, "uuid ", sizeof ("uuid ") - 1);
      ptr += sizeof ("uuid ") - 1;
      ptr = op->uuid.append (ptr);
      *ptr++ = '\n';

      f.alloc (ptr - cur);
    }

#define CMP_OUT(v)    if (expect_false (op->v != arch->v)) f.put (KW (v), op->v)
#define CMP_OUT2(k,v) if (expect_false (op->v != arch->v)) f.put (KW (k), op->v)

  CMP_OUT (x);
  CMP_OUT (y);

  CMP_OUT (type);
  CMP_OUT (subtype);
  CMP_OUT (direction);

  CMP_OUT (name);
  CMP_OUT (name_pl);
  CMP_OUT (speed);

  // speed_left is a major time-burner, and has good locality, so
  // we use a simple lookup-cache to avoid the very slow printf.
  if (op->speed_left != arch->speed_left)
    {
      static double last_speed_left = 0.;
      static char   last_speed_left_str [256] = "sl 0\n";
      static int    last_speed_left_len = sizeof ("sl 0\n") - 1;

      if (last_speed_left != op->speed_left)
        {
          last_speed_left = op->speed_left;
          last_speed_left_len = sizeof ("sl ") - 1
                              + sprintf (last_speed_left_str + sizeof ("sl ") - 1, "%.7g\n", last_speed_left);
        }

      f.add (last_speed_left_str, last_speed_left_len);
    }

  CMP_OUT (title);
  CMP_OUT (race);
  CMP_OUT (slaying);
  CMP_OUT (skill);

  CMP_OUT (tag);
  CMP_OUT (custom_name);

  if (object *owner = op->owner)
    if (const char *ref = owner->ref ())
      f.put (KW(owner), ref);

  // memory, attacked_by, chosen_skill, spellitem, spell, current_weapon, arch not saved

  CMP_OUT (other_arch);

  if (op->msg  != arch->msg ) f.put (KW(msg) , KW(endmsg) , op->msg );
  if (op->lore != arch->lore) f.put (KW(lore), KW(endlore), op->lore);

  if (op->face          != arch->face         ) f.put (KW(face)         , op->face          ? &faces [op->face         ] : 0);
  if (op->sound         != arch->sound        ) f.put (KW(sound)        , op->sound         ? &faces [op->sound        ] : 0);
  if (op->sound_destroy != arch->sound_destroy) f.put (KW(sound_destroy), op->sound_destroy ? &faces [op->sound_destroy] : 0);

  if (op->animation_id != arch->animation_id)
    if (op->has_anim ())
      f.put (KW(animation), op->anim ().name);
    else
      {
        f.put (KW(animation));
        op->flag [FLAG_ANIMATE] = false; // TODO: why force to false here?
      }

  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_OUT2 (move_state, move_status);
  CMP_OUT (attack_movement);
  CMP_OUT (nrof);
  CMP_OUT (level);
  CMP_OUT (attacktype);

  // using memcmp here seems to be a loss - is gcc vectorising?
  for (int i = 0; i < NROFATTACKS; i++)
    if (expect_false (op->resist[i] != arch->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
  if (op->material != arch->material)
    f.put (KW(materialname), op->material->name);

  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 (op->flag [FLAG_IS_LINKED])
    if (auto (ol, op->find_link ()))
      f.put (KW(connected), ol->id);

  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 (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);

  object::flags_t diff = (op->flag ^ arch->flag) & flagmask;

#if stdcpp // we need gcc, sorry
  if (diff [FLAG_OBJ_ORIGINAL])
    f.put (flag_names [FLAG_OBJ_ORIGINAL], op->flag [FLAG_OBJ_ORIGINAL] ? CS(1) : CS(0));

  diff.reset (FLAG_OBJ_ORIGINAL);

  // quickly test whether any other flags differ
  if (expect_true (diff.any ()))
    for (int i = 0; i < NUM_FLAGS; i++)
      if (expect_false (diff [i]))
        f.put (flag_names [i], op->flag [i] ? CS(1) : CS(0));
#else
  // use sgi extensions
  for (int i = diff._Find_first (); i < diff.size (); i = diff._Find_next (i))
    f.put (flag_names [i], op->flag [i] ? CS(1) : CS(0));
#endif

  // save body locations. gcc's memcmp does an abysmal job when used
  for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
    if (expect_false (op->slot[i].info != arch->slot[i].info))
      f.put (body_locations[i].kw, op->slot[i].info);
}

/*
 * 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.
 */
bool
object::write (object_freezer &f)
{
  if (expect_false (is_arch ()))
    {
      f.put (KW(object), arch->archname);
      write_diff (f, this, archetype::empty);
    }
  else
    {
      f.put (KW(arch), arch->archname);
      write_diff (f, this, arch);
    }

  for (object *tmp = inv; tmp; tmp = tmp->below)
    tmp->write (f);

  f.put (this);
  f.put (KW(end));

  return true;
}

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

// generic resource file load,
// currently supports: region, treasures, archetypes
bool
load_resource_file_ (const char *filename)
{
  object_thawer f (filename);

  for (;;)
    {
      coroapi::cede_to_tick ();

      switch (f.kw)
        {
          case KW_region:
            if (!region::read (f))
              return false;
            break;

          case KW_treasure:
          case KW_treasureone:
            if (!treasurelist::read (f))
              return false;
            break;

          case KW_object:
            if (!archetype::read (f))
              return false;
            break;

          case KW_EOF:
            return true;

          default:
            if (!f.parse_error ("resource file"))
              return false;

            f.next ();
            break;
        }
    }
}

Revision:	1.169
Committed:	Sun May 1 16:58:15 2011 UTC (13 years ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.168:	+1 -1 lines
Log Message:	* empty log message *