[ViewVC] Diff of: cvs/deliantra/server/common/loader.C

Comparing deliantra/server/common/loader.C (file contents):
Revision 1.157 by root, Thu Apr 29 12:24:03 2010 UTC vs.
Revision 1.182 by root, Wed Nov 14 21:19:41 2018 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
+ * Copyright (©) 2018 Marc Alexander Lehmann / the Deliantra team
- * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992 Frank Tore Johansen
  *
  * Deliantra is free software: you can redistribute it and/or modify it under
  * the terms of the Affero GNU General Public License as published by the
  * Free Software Foundation, either version 3 of the License, or (at your
  * option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the Affero GNU General Public License
  * and the GNU General Public License along with this program. If not, see
  * <http://www.gnu.org/licenses/>.
  *
  * The authors can be reached via e-mail to <support@deliantra.net>
  */
 #include <global.h>
 #include <sproto.h>
   "spell_glyph",                /* 205 */
   NULL
 };
 /* This function checks the object after it has been loaded (when we
  * get the 'end' in the input stream).  This function can be used to
  * deal with legacy objects where fields may have changed.  It can also be used
  * to check for objects to make sure there are no common errors.
  */
 void
 object::post_load_check ()
       type = 0;
     }
   switch (type)
     {
+      case RANGED:
       case BOW:
       case WAND:
       case ROD:
       case HORN:
         if (slot [body_range].info != -1)
             LOG (llevError, "ITEMBUG: %s: body_shield %d != -1\n", debug_desc (), slot [body_shield].info);
             slot [body_shield].info = -1;
           }
         break;
+      case CONTAINER:
+        if (nrof)
+          {
+            LOG (llevError, "ITEMBUG: %s: stackable container (nrof %d)\n", debug_desc (), (int)nrof);
+            nrof = 0;
+          }
+        break;
       case PLAYER:
         if (slot [body_shield].info != 1)
           {
             LOG (llevError, "ITEMBUG: %s: body_shield %d != 1\n", debug_desc (), slot [body_shield].info);
             slot [body_shield].info = 1;
    * this isn't perfect (things won't be properly pluralised), but works to
    * that degree (5 heart is still quite understandable).  But the case we
    * also have to catch is if this object is not using the normal name for
    * the object.  In that case, we also want to use the loaded name.
    * Otherwise, what happens is that the the plural name will lose
    * information (appear as just 'hearts' and not 'goblins heart')
    */
   if (arch && name != arch->object::name && name_pl == arch->object::name_pl)
     name_pl = 0;
   if (!name_pl)
       // TODO: fix firewall object on map
       /* Firewall is bizarre in that spell type was stored in dam. Rest are 'normal'
        * in that spell was stored in sp.
        */
       //LOG (llevError, "old spellcasting object found: %s", debug_desc ());
-      object *tmp = get_archetype (spell_mapping[type == FIREWALL ? stats.dam : stats.sp]);
+      object *tmp = archetype::get (spell_mapping[type == FIREWALL ? stats.dam : stats.sp]);
       insert_ob_in_ob (tmp, this);
       randomitems = 0;
     }
   /* spellbooks & runes use slaying.  But not to arch name, but to spell name */
     }
   // if the object has an animation, try to provide a default face
   if (has_anim ())
     {
-      const animation &anim_ob = anim ();
       if (anim_speed)
         // if this item is time-animated, force the last frame
         animate_object (this, 0);
       else if (flag [FLAG_MONSTER])
         // if it is a monster, set appropriate facing
         {
           negate = 1;
           str++;
         }
-      for (const flagstr *f = move_flags; f < move_flags + sizeof (move_flags) / sizeof (move_flags [0]); ++f)
+      for (const flagstr *f = move_flags; f < move_flags + array_length (move_flags); ++f)
         {
           if (!strcmp (f->name, str))
             {
               if (negate)
                 mt &= ~f->flags;
 bool
 object::parse_kv (object_thawer &f)
 {
   object *op_inv = inv;
-  key_value *last_kv = key_values;
   for (;;)
     {
       switch (f.kw)
         {
             f.delayed_deref (this, owner, f.get_str ());
             break;
           case KW_animation:
             {
-              this->clr_flag (FLAG_ANIMATE);
+              clr_flag (FLAG_ANIMATE);
               animation_id = 0;
-              if (f.has_value () && (animation_id = find_animation (f.get_str ())))
+              if (f.has_value () && (animation_id = animation::find (f.get_str ()).number))
-                this->set_flag (FLAG_ANIMATE); //TODO: should not be forced to true here
+                set_flag (FLAG_ANIMATE); //TODO: should not be forced to true here
             }
             break;
           case KW_last_heal:  f.get (last_heal);  break;
           case KW_last_sp:    f.get (last_sp);    break;
           case KW_move_type:            set_move (move_type , f); break;
           case KW_move_on:              set_move (move_on   , f); break;
           case KW_move_off:             set_move (move_off  , f); break;
           case KW_move_slow:            set_move (move_slow , f); break;
-            /* These are all legacy - any new objects should use the move_ .. values */
-          case KW_no_pass:
-            {
-              if (f.get_sint32 ())
-                move_block = MOVE_ALL;
-              else
-                move_block = 0;
-            }
-            break;
-            /* These are all legacy - any new objects should use the move_ .. values */
-          case KW_walk_on:
-            {
-              if (f.get_sint32 ())
-                move_on |= MOVE_WALK;
-              else
-                move_on &= ~MOVE_WALK;
-            }
-            break;
-            /* These are all legacy - any new objects should use the move_ .. values */
-          case KW_walk_off:
-            {
-              if (f.get_sint32 ())
-                move_off |= MOVE_WALK;
-              else
-                move_off &= ~MOVE_WALK;
-            }
-            break;
-            /* These are all legacy - any new objects should use the move_ .. values */
-          case KW_fly_on:
-            {
-              if (f.get_sint32 ())
-                move_on |= MOVE_FLY_LOW;
-              else
-                move_on &= ~MOVE_FLY_LOW;
-            }
-            break;
-            /* These are all legacy - any new objects should use the move_ .. values */
-          case KW_fly_off:
-            {
-              if (f.get_sint32 ())
-                move_off |= MOVE_FLY_LOW;
-              else
-                move_off &= ~MOVE_FLY_LOW;
-            }
-            break;
             //TODO: remove these after converting archetypes
           case KW_can_use_wand:
             GET_FLAG (this, FLAG_USE_RANGE);
             break;
-            /* These are all legacy - any new objects should use the move_ .. values */
-          case KW_flying:
-            {
-              if (f.get_sint32 ())
-                move_type |= MOVE_FLY_LOW;
-              else
-                move_type &= ~MOVE_FLY_LOW;
-            }
-            break;
           case KW_identified:
             GET_FLAG (this, FLAG_IDENTIFIED);
             //TODO: move to check_object or so
             if (this->flag [FLAG_IDENTIFIED])
           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_is_transparent_floor: GET_FLAG (this, FLAG_IS_TRANSPARENT_FLOOR); 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_is_buildable:         GET_FLAG (this, FLAG_IS_BUILDABLE); break;
           case KW_destroy_on_death:     GET_FLAG (this, FLAG_DESTROY_ON_DEATH); break;
           case KW_treasure_env:         GET_FLAG (this, FLAG_TREASURE_ENV); break;
           case KW_precious:             GET_FLAG (this, FLAG_PRECIOUS); break;
           case KW_random_speed:         GET_FLAG (this, FLAG_RANDOM_SPEED); break;
+          case KW_is_quad:              GET_FLAG (this, FLAG_IS_QUAD); break;
           case KW_armour:               f.get (resist[ATNR_PHYSICAL]); break;
           case KW_resist_physical:      f.get (resist[ATNR_PHYSICAL]); break;
           case KW_resist_magic:         f.get (resist[ATNR_MAGIC]); break;
           case KW_resist_fire:          f.get (resist[ATNR_FIRE]); break;
             f.next ();
             return true;
           case KW_ERROR:
-            // append as key value pair (do not use kv_set as it prepends)
-            // we also do not even try to find old values, duplicate keys stay duplicate
+            // we do not even try to find old values, duplicate keys stay duplicate
-            {
+            // the list gets reversed after loading
-              key_value *kv = new key_value;
+            kv.add (shstr (f.kw_str), shstr (f.value));
-              kv->next  = 0;
-              kv->key   = shstr (f.kw_str);
-              kv->value = shstr (f.value);
-              if (!last_kv)
-                key_values = last_kv = kv;
-              else
-                {
-                  while (last_kv->next)
-                    last_kv = last_kv->next;
-                  last_kv->next = kv;
-                  last_kv       = kv;
-                }
-            }
-            //fprintf (stderr, "addkv(%s,%s)\n", f.kw_str, f.value);//D
             break;
           default:
             if (!f.parse_error ("object", name))
               return false;
   archetype *arch = archetype::find (f.get_str ());
   if (!arch)
     {
-      LOG (llevError, "object refering to nonexistant archetype '%s'.\n", f.get_str ());
+      LOG (llevError, "object referring to nonexistent archetype '%s'.\n", f.get_str ());
       arch = archetype::find (shstr_earthwall);
     }
   assert (arch); //D maybe use exception handling of sorts?
   if (!op->parse_kv (f))
     {
       op->destroy ();
       return  0;
     }
+  // the loader reverses the ordering of kv-pairs, so we reverse it again after loading
+  // that greatly simplifies the loading code.
+  op->kv.reverse ();
   op->post_load_check ();
   return op;
 }
  * override values and in c_wiz to mutate values.
  */
 int
 set_variable (object *op, char *buf)
 {
-  object_thawer f (buf, (AV *)0);
+  object_thawer f (format ("%s\nend", buf), (AV *)0);
   return op->parse_kv (f);
 }
 // compare *op against *arch and output differences
     KW_NULL,
     KW_applied,
     KW_unpaid,
     KW_can_use_shield,
     KW_no_pick,
-    KW_NULL, // walk_on
+    KW_is_transparent_floor,
     /* 10 */
     KW_NULL, // no_pass
     KW_is_animated,
     KW_NULL, // slow_move
     KW_NULL, // flying
   } flagmask;
   /* This saves the key/value lists.  We do it first so that any
    * keys that match field names will be overwritten by the loader.
    */
-  for (key_value *kv = op->key_values; kv; kv = kv->next)
+  for (key_value *kv = op->kv.first; kv; kv = kv->next)
-    if (!arch->key_values || arch->kv (kv->key) != kv->value)
+    if (arch->kv.empty () || arch->kv [kv->key] != kv->value)
       f.put (kv->key, kv->value);
   if (op->uuid)
     {
       // highly optimised - this is often 25% of all data written
       static int    last_speed_left_len = sizeof ("sl 0\n") - 1;
       if (last_speed_left != op->speed_left)
         {
           last_speed_left = op->speed_left;
+          // .7g loses precision even for float, but gives nice round numbers and smaller files
+          // maybe hex format or a raw binary dump of the float is good enough, more exact, and much faster?
+          // (printf is typically very slow)
           last_speed_left_len = sizeof ("sl ") - 1
                               + sprintf (last_speed_left_str + sizeof ("sl ") - 1, "%.7g\n", last_speed_left);
         }
       f.add (last_speed_left_str, last_speed_left_len);
 #endif
   // save body locations. gcc's memcmp does an abysmal job when used
   for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
     if (expect_false (op->slot[i].info != arch->slot[i].info))
-      f.put (body_locations[i].save_name, op->slot[i].info);
+      f.put (body_locations[i].kw, op->slot[i].info);
 }
 /*
  * Dumps all variables in an object to a file.
  * If bit 0 of flag is set, unpaid objects will be saved.  As of now,
 {
   object_thawer f (filename);
   for (;;)
     {
+      coroapi::cede_to_tick ();
       switch (f.kw)
         {
           case KW_region:
             if (!region::read (f))
               return false;

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/common/loader.C (file contents): Revision 1.157 by root, Thu Apr 29 12:24:03 2010 UTC vs. Revision 1.182 by root, Wed Nov 14 21:19:41 2018 UTC

Diff Legend

Comparing deliantra/server/common/loader.C (file contents):
Revision 1.157 by root, Thu Apr 29 12:24:03 2010 UTC vs.
Revision 1.182 by root, Wed Nov 14 21:19:41 2018 UTC