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>

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

/* 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 bool loading_arch;

/* 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)
{
  /* 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 = 0;

  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) && loading_arch)
    {
      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;
        }

      int 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 && !loading_arch)
    {
      /* Fireall is bizarre in that spell type was stored in dam.  Rest are 'normal'
       * in that spell was stored in sp.
       */
      object *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 && !loading_arch)
    {
      object *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)
{
  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 },
    { "all"     , MOVE_ALL },
  };

  if (!str)
    {
      mt = 0;
      return;
    }

  if (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 + sizeof (move_flags) / sizeof (move_flags [0]); ++f)
        {
          if (!strcmp (f->name, str))
            {
              if (negate)
                mt &= ~f->flags;
              else
                mt |=  f->flags;

              goto next;
            }
        }

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

next: ;
    }
}

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

bool
object::parse_kv (object_thawer &f)
{
  assert (f.kw == KW_object || f.kw == KW_arch);

  if (f.kw == KW_object)
    f.get (name); // preset name from object name

  f.next ();

  object *op_inv = inv;

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

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

            uuid = gen_uuid ();
            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_arch:
            {
              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.
                CLEAR_FLAG (tmp, FLAG_OBJ_ORIGINAL);
                CLEAR_FLAG (tmp, 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;
              }
            }
            continue;

          case KW_other_arch:
            other_arch =
              loading_arch
                ? archetype::get  (f.get_str ())
                : archetype::find (f.get_str ());

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

          case KW_animation:
            {
              CLEAR_FLAG (this, FLAG_ANIMATE);
              animation_id = 0;

              const char *str = f.get_str ();
              if (str && (animation_id = find_animation (str)))
                SET_FLAG (this, FLAG_ANIMATE);
            }
            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_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 = face_find (f.get_str ());
            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 (materialname); break;

            /* These are the new values */
          case KW_move_block:           set_move (move_block, f.get_str ()); break;
          case KW_move_allow:           set_move (move_allow, f.get_str ()); break;
          case KW_move_type:            set_move (move_type, f.get_str ()); break;
          case KW_move_on:              set_move (move_on, f.get_str ()); break;
          case KW_move_off:             set_move (move_off, f.get_str ()); break;
          case KW_move_slow:            set_move (move_slow, f.get_str ()); 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 (QUERY_FLAG (this, FLAG_IDENTIFIED))
              CLEAR_FLAG (this, FLAG_KNOWN_MAGICAL);

            break;

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

          case KW_friendly:
            if (f.get_sint32 ())
              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_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_was_wiz:              GET_FLAG (this, FLAG_WAS_WIZ); break;
          case KW_no_fix_player:        GET_FLAG (this, FLAG_NO_FIX_PLAYER); 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_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;
          case KW_glow_radius:          f.get (glow_radius); break;
          case KW_weapontype:           f.get (weapontype); break;
          case KW_tooltype:             f.get (tooltype); break;
          case KW_casting_time:         f.get (casting_time); break;
          case KW_elevation:            f.get (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:           f.get (body_info[0]); break;
          case KW_body_arm:             f.get (body_info[1]); break;
          case KW_body_torso:           f.get (body_info[2]); break;
          case KW_body_head:            f.get (body_info[3]); break;
          case KW_body_neck:            f.get (body_info[4]); break;
          case KW_body_skill:           f.get (body_info[5]); break;
          case KW_body_finger:          f.get (body_info[6]); break;
          case KW_body_shoulder:        f.get (body_info[7]); break;
          case KW_body_foot:            f.get (body_info[8]); break;
          case KW_body_hand:            f.get (body_info[9]); break;
          case KW_body_wrist:           f.get (body_info[10]); break;
          case KW_body_waist:           f.get (body_info[11]); break;
          case KW_can_apply:
            break;

          case KW_connected:
            add_button_link (this, map, f.get_sint32 ());
            break;

          case KW_randomitems:
            if (f.get_str ())
              {
                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 ());
              }
            break;

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

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

          case KW_editable:
          case KW_editor_folder:
            break;

          case KW_end:
            check_loaded_object (this);

            if (!loading_arch)
              instantiate ();

            f.next ();
            return true;

          case KW_ERROR:
            set_ob_key_value (this, f.kw_str, f.value, true);
            //fprintf (stderr, "addkv(%s,%s)\n", f.kw_str, f.value);//D
            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 refering to nonexistant archetype '%s'.\n", f.get_str ());
      arch = archetype::find ("earthwall");
    }

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

  object *op = object::create ();

  op->map = map;
  arch->clone.copy_to (op);
  // copy_to activates, this should be fixed properly
  op->deactivate ();

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

  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 (buf, (AV *)0);

  f.kw = KW_arch; // special hack so that parse_kv skips
  return op->parse_kv (f);
}

/* 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
static void
write_diff (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);

  if (op->face != tmp->face) f.put (KW_face, op->face ? &faces [op->face] : 0);

  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.
 */
bool
object::write (object_freezer &f)
{
  /* Even if the object does have an owner, it would seem that we should
   * still save it.
   */
  if (owner)
    return true;

  archetype *at = arch ? (archetype *)arch : empty_archetype;

  f.put (KW_arch, at->name);
  write_diff (f, this, &at->clone);

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

  bool success   = false;
  bool seen_arch = false;

  f.next ();

  for (;;)
    {
      switch (f.kw)
        {
          case KW_region:
            if (!region::read (f))
              goto finish;
            break;

          case KW_treasure:
          case KW_treasureone:
            if (!treasurelist::read (f))
              goto finish;
            break;

          case KW_object:
            seen_arch = true;
            if (!archetype::read (f))
              goto finish;
            break;

          case KW_EOF:
            success = true;
            goto finish;

          default:
            if (!f.parse_error ("resource file"))
              goto finish;
        }
    }

finish:
  if (seen_arch)
    init_archetype_pointers ();

  return success;
}

Revision:	1.70
Committed:	Tue Apr 17 18:40:31 2007 UTC (19 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.69:	+21 -5 lines
Log Message:	- load_resource_file cna now load archetypes, regions and treasures freely intermingled. archetypes and treasures makes a lot of actual sense, too. (this has not been tested, but unlikely not to work :)