server/common/loader.C


/*
    CrossFire, A Multiplayer game for X-windows

    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-devel@real-time.com
*/

/* 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 <newserver.h>
#include <sproto.h>

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

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

extern int arch_init;

// return a suitable strign describign an objetc in enough detail to find it
// used only in check_loaded_object: TODO remove static, move it elsewhere and
// use it in more log messages.
static char *
op_debug_info_ (object *op, char *info)
{
  char info2[256 * 3];
  char *p = info;

  p += snprintf (p, 256, "%d=\"%s%s%s\"",
                 op->count, op->name ? (const char *) op->name : "(anon)", op->title ? " " : "", op->title ? (const char *) op->title : "");

  if (op->env)
    p += snprintf (p, 256, "(in %s)", op_debug_info_ (op->env, info2));

  if (op->map)
    p += snprintf (p, 256, "(on %s@%d+%d)", op->map->path, op->x, op->y);

  return info;
}

static char *
op_debug_info (object *op)
{
  static char info[256 * 3];

  return op_debug_info_ (op, info);
}

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

  /* We do some specialized 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 pluralized), but works to
   * that degree (5 heart is still quite understandable).  But the case we
   * also have to catch is if this object is not using the normal name for
   * the object.  In that case, we also want to use the loaded name.
   * Otherwise, what happens is that the the plural name will lose
   * information (appear as just 'hearts' and not 'goblins heart') 
   */
  if (op->arch && op->name != op->arch->clone.name && op->name_pl == op->arch->clone.name_pl)
    op->name_pl = NULL;

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

  /* objects now have a materialname.  try to patch it in */
  if (!(IS_WEAPON (op) && op->level > 0))
    {
      if (op->map != NULL)
        set_materialname (op, op->map->difficulty, NULL);
      else
        set_materialname (op, 5, NULL);
    }
  /* only do these when program is first run - a bit
   * excessive to do this at every run - most of this is
   * really just to catch any errors - program will still run, but
   * not in the ideal fashion.
   */
  if ((op->type == WEAPON || op->type == BOW) && arch_init)
    {
      if (!op->skill)
        {
          LOG (llevError, "Weapon %s lacks a skill.\n", op_debug_info (op));
        }
      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_info (op), 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_info (op));
          op->gen_sp_armour = op->last_heal;
          op->last_heal = 0;
        }
      if (editor)
        ip = 0;
      else
        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_info (op), 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_info (op), ip, op->item_power);
        }

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

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

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

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

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

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

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

}

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

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

  mt = 0;

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

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

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

                  break;
                }
            }

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

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

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

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

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

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

              break;

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

            case KW_name:
              thawer.get (op->name);
              break;
            case KW_name_pl:
              thawer.get (op->name_pl);
              break;
            case KW_title:
              thawer.get (op->title);
              break;
            case KW_custom_name:
              thawer.get (op->custom_name);
              break;
            case KW_attach:
              thawer.get_ornull (op->attach);
              break;
            case KW_skill:
              thawer.get_ornull (op->skill);
              break;
            case KW_race:
              thawer.get_ornull (op->race);
              break;
            case KW_slaying:
              thawer.get_ornull (op->slaying);
              break;

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

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

                    object *tmp;

                    if (arch != NULL)
                      tmp = arch_to_object (arch);
                    else
                      {
                        tmp = get_object ();
                        /* record the name of the broken object */
                        tmp->name = str;
                      }

                    parse_object (tmp, thawer, map_flags);

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

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

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

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

                    if (op->arch != NULL)
                      copy_object (&op->arch->clone, op);
                    else if (!arch_init)
                      /* record the name of the broken object */
                      op->name = str;
                  }
              }
              break;

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

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

                if (!str)
                  {
                    op->animation_id = 0;
                    CLEAR_FLAG (op, FLAG_ANIMATE);
                  }
                else
                  {
                    op->animation_id = find_animation (str);
                    SET_FLAG (op, FLAG_ANIMATE);
                  }
              }

              break;

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

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

              //TODO: maybe do in check_object
              if (!(map_flags & MAP_STYLE))
                {
                  if (op->speed < 0)
                    op->speed_left = op->speed_left - RANDOM () % 100 / 100.0;

                  update_ob_speed (op);
                }

              break;

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

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

            case KW_x:
              thawer.get (op->x);
              break;
            case KW_y:
              thawer.get (op->y);
              break;
            case KW_Str:       // uppercase alias
            case KW_str:
              thawer.get (op->stats.Str);
              break;
            case KW_Dex:       // uppercase alias
            case KW_dex:
              thawer.get (op->stats.Dex);
              break;
            case KW_Con:       // uppercase alias
            case KW_con:
              thawer.get (op->stats.Con);
              break;
            case KW_Wis:       // uppercase alias
            case KW_wis:
              thawer.get (op->stats.Wis);
              break;
            case KW_Cha:       // uppercase alias
            case KW_cha:
              thawer.get (op->stats.Cha);
              break;
            case KW_Int:       // uppercase alias
            case KW_int:
              thawer.get (op->stats.Int);
              break;
            case KW_Pow:       // uppercase alias
            case KW_pow:
              thawer.get (op->stats.Pow);
              break;
            case KW_hp:
              thawer.get (op->stats.hp);
              break;
            case KW_maxhp:
              thawer.get (op->stats.maxhp);
              break;
            case KW_sp:
              thawer.get (op->stats.sp);
              break;
            case KW_maxsp:
              thawer.get (op->stats.maxsp);
              break;
            case KW_grace:
              thawer.get (op->stats.grace);
              break;
            case KW_maxgrace:
              thawer.get (op->stats.maxgrace);
              break;

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

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

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

              break;

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

              break;

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

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

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

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

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


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

              break;

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

            case KW_friendly:
              GET_FLAG (op, FLAG_FRIENDLY);
              //TODO: move to check_object or so
              if (op->type != PLAYER && QUERY_FLAG (op, FLAG_FRIENDLY))
                add_friendly_object (op);
              break;

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

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

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

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

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

            case KW_randomitems:
              op->randomitems = find_treasurelist (thawer.get_str ());
              break;

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

            case KW_lore:
              {
                shstr msgbuf;

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

            case KW_editable:
            case KW_editor_folder:
              break;

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

            case KW_end:
              check_loaded_object (op);

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

              return ismore ? LL_MORE : LL_NORMAL;

            case KW_EOF:
              return LL_EOF;

            case KW_ERROR:
              set_ob_key_value (op, thawer.line, thawer.last_value, true);
              //printf ("addkv(%s,%s)\n", thawer.line, thawer.get_str());//D

              //TODO: skip line, ugly, factor parsing better
              if (thawer.last_value)
                thawer.line = thawer.last_value;

              thawer.line += strlen (thawer.line) + 1;

              break;

            default:
              LOG (llevError, "UNSUPPORTED KEYWORD IN MAP: \"%s\", bug in normaliser. skipping.\n", keyword_str[kw]);
              break;
        }
    }
}

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

int
load_object (object_thawer & fp, object *op, int map_flags)
{
  return parse_object (op, fp, map_flags);
}


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

  strcpy (msgbuf, "");
  strcpy (lorebuf, "");
  retval = parse_object (op, thawer, 0);
  yy_switch_to_buffer (yycurbuf);
  yy_delete_buffer (yybufstate);
  yy_pop_state ();
  return retval;
#endif
}

/* This array equates the FLAG_ values with the V_ values.  Use -1 to
 * put gaps in the array that should not be processed.
 * The order matches the order of the define values in 'define.h'.
 */

/* This is a list of pointers 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 char *const flag_names[NUM_FLAGS + 1] = {
  "alive", "wiz", NULL, NULL, "was_wiz", "applied", "unpaid",
  "can_use_shield", "no_pick", NULL /* walk_on */ , NULL /* no_pass */ ,        /* 10 */
  "is_animated", NULL /* slow_move */ ,
  NULL /* flying */ , "monster", "friendly", "generator",
  "is_thrown", "auto_apply", "treasure", "player sold", /* 20 */
  "see_invisible", "can_roll", "overlay_floor",
  "is_turnable", NULL /* walk_off */ , NULL /* fly_on */ ,
  NULL /*fly_off */ , "is_used_up", "identified", "reflecting", /* 30 */
  "changing", "splitting", "hitback", "startequip",
  "blocksview", "undead", "scared", "unaggressive",
  "reflect_missile", "reflect_spell",   /* 40 */
  "no_magic", "no_fix_player", "is_lightable", "tear_down",
  "run_away", NULL /*pass_thru */ , NULL /*can_pass_thru */ ,
  "pick_up", "unique", "no_drop",       /* 50 */
  NULL /* wizcast */ , "can_cast_spell", "can_use_scroll", "can_use_range",
  "can_use_bow", "can_use_armour", "can_use_weapon",
  "can_use_ring", "has_ready_range", "has_ready_bow",   /* 60 */
  "xrays", NULL, "is_floor", "lifesave", "no_strength", "sleep",
  "stand_still", "random_move", "only_attack", "confused",      /* 70 */
  "stealth", NULL, NULL, "cursed", "damned",
  "see_anywhere", "known_magical", "known_cursed",
  "can_use_skill", "been_applied",      /* 80 */
  "has_ready_scroll", "can_use_rod", NULL,
  "can_use_horn", "make_invisible", "inv_locked", "is_wooded",
  "is_hilly", "has_ready_skill", "has_ready_weapon",    /* 90 */
  "no_skill_ident", "is_blind", "can_see_in_dark", "is_cauldron",
  "is_dust", "no_steal", "one_hit", NULL, "berserk", "neutral", /* 100 */
  "no_attack", "no_damage", NULL, NULL, "activate_on_push",
  "activate_on_release", "is_water", "use_content_on_gen", NULL, "is_buildable",        /* 110 */
  NULL
};


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

void
init_vars ()
{
}

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

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

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

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

// compare *op against *tmp and output differences
void
put (object_freezer & f, object *op, object *tmp)
{
  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 != NULL; 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 == NULL || 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_object function.
   */

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

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

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

  CMP_OUT (other_arch);
  CMP_OUT (face);

  if (!op->face || !op->face->name)
    printf ("ERRFACE<%s,%s, face %p,%p, fname%s>\n", &tmp->name, &op->name, tmp->face, op->face, op->face ? &op->face->name : "<noface>");      //D

  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_OUT (material);
  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 (!COMPARE_FLAGS (op, tmp))
    for (i = 0; i <= NUM_FLAGS; i++)
      if (flag_names[i] && (QUERY_FLAG (op, i) != QUERY_FLAG (tmp, i)))
        f.put (flag_names[i], QUERY_FLAG (op, 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.
 * If bit 1 of flag is set, don't remove the object after save.  As of now,
 * all of the callers are setting this.
 */

void
save_object (object_freezer & fp, object *op, int flag)
{
  archetype *at;
  object *tmp, *old;

  /* Even if the object does have an owner, it would seem that we should
   * still save it.
   */
  if (op->owner)
    return;

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

  if ((at = op->arch) == NULL)
    at = empty_archetype;

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

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

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

  old = NULL;

  if (flag & 2)
    for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
      save_object (fp, tmp, flag);
  else
    /* Slightly different logic because tmp/op will be removed by
     * the save_object we call.  So we just keep looking at op->inv
     * until there is nothing left.  In theory, the variable old
     * should not be needed, as recursive loops shouldn't happen.
     */
    while ((tmp = op->inv) != NULL)
      {
        if (old == tmp)
          {
            LOG (llevError, " Recursive loop in inventory\n");
            break;
          }

        save_object (fp, tmp, flag);
        old = tmp;
      }

  if (!(flag & 2))
    {
      remove_ob (op);
      free_object (op);
    }

  fp.put (op);
  fprintf (fp, "end\n");
}
Revision:	1.13
Committed:	Mon Sep 11 20:28:37 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.12:	+1 -1 lines
Log Message:	implement owner pointer using refcounted refptr templates