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

Comparing deliantra/server/common/loader.C (file contents):
Revision 1.107 by root, Fri Apr 11 14:09:56 2008 UTC vs.
Revision 1.114 by root, Sat May 3 11:14:50 2008 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992,2007 Frank Tore Johansen
  *
  * Deliantra is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * You should have received a copy of 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>
  */
-/* 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>
       || type == AMULET  || type == GIRDLE
       || type == BRACERS || type == CLOAK)
     {
       if (last_heal)
         {
-          LOG (llevDebug, "Object %s still has last_heal set, not gen_sp_armour\n", debug_desc ());
+          LOG (llevError, "Object %s still has last_heal set, not gen_sp_armour\n", debug_desc ());
           gen_sp_armour = last_heal;
           last_heal = 0;
         }
       int ip = calc_item_power (this, 0);
        ((type == POTION || type == ALTAR) && stats.sp)) && !inv && !loading_arch)
     {
       /* 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]);
       insert_ob_in_ob (tmp, this);
       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 ((type == SPELLBOOK || type == RUNE) && slaying && !inv && !loading_arch)
     {
+      LOG (llevError, "spellbook/rune found without inv but slaying: %s", debug_desc ());
       object *tmp = get_archetype_by_object_name (slaying);
       insert_ob_in_ob (tmp, this);
       randomitems = NULL;   /* So another spell isn't created for this object */
       /* without this, value is all screwed up */
       value = arch->value * inv->value;
   if (QUERY_FLAG (this, FLAG_MONSTER))
     {
       if (stats.hp > stats.maxhp)
         {
-          LOG (llevDebug, "Monster %s has hp set higher than maxhp (%d>%d)\n", debug_desc (), stats.hp, stats.maxhp);
+          LOG (llevInfo, "Monster %s has hp set higher than maxhp (%d>%d)\n", debug_desc (), stats.hp, stats.maxhp);
           stats.maxhp = stats.hp;
         }
       /* The archs just need to be updated for this */
       if (move_type == 0)
         move_type = MOVE_WALK;
     }
   if ((QUERY_FLAG (this, FLAG_GENERATOR) && QUERY_FLAG (this, FLAG_CONTENT_ON_GEN)) || type == CREATOR || type == CONVERTER)
-    {
-      /* Object will duplicate it's content as part of the
+    /* Object will duplicate it's content as part of the
-       * generation process. To do this, we must flag inventory
+     * generation process. To do this, we must flag inventory
-       * so it remains unevaluated concerning the randomitems and
+     * so it remains unevaluated concerning the randomitems and
-       * the living (a demonlord shouldn't cast from inside generator!)
+     * the living (a demonlord shouldn't cast from inside generator!)
-       */
+     */
+    /* ??? this *should* be done elsewhere, e.g. after map loading etc. */
-      flag_inv (this, FLAG_IS_A_TEMPLATE);
+    flag_inv (this, FLAG_IS_A_TEMPLATE);
-    }
-  /* Handle player movers.  We use move_type for player movers
+  /* 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
+   * on them). If move_type is set, presume person knows what they
    * are doing, otherwise, set move_type based on maxhp value.
    */
   if (type == PLAYERMOVER)
     {
       if (!move_type)
               goto next;
             }
         }
-      LOG (llevDebug, "common/loader.C: set_move - unknown move string '%s'\n", str);
+      LOG (llevError, "common/loader.C: set_move - unknown move string '%s'\n", str);
 next: ;
     }
 }
 bool
 object::parse_kv (object_thawer &f)
 {
   object *op_inv = inv;
+  key_value *last_kv = key_values;
   for (;;)
     {
       switch (f.kw)
         {
               }
             }
             continue;
           case KW_other_arch:
-            other_arch =
-              loading_arch
+            if (loading_arch == this)
-                ? archetype::get  (f.get_str ())
+              archetype::postpone_arch_ref (loading_arch->other_arch, f.get_str ());
+            else
+              {
-                : archetype::find (f.get_str ());
+                other_arch = archetype::find (f.get_str ());
-            if (!other_arch)
+                if (!other_arch)
-              f.parse_warn (format ("%s uses unknown other_arch '%s'.\n", debug_desc (), f.get_str ()));
+                  f.parse_warn (format ("%s uses unknown other_arch '%s'.\n", debug_desc (), f.get_str ()));
+              }
             break;
           case KW_owner:
             f.delayed_deref (this, owner, f.get_str ());
             break;
           case KW_is_turnable:          GET_FLAG (this, FLAG_IS_TURNABLE); break;
           case KW_is_used_up:           GET_FLAG (this, FLAG_IS_USED_UP); break;
           case KW_alive:                GET_FLAG (this, FLAG_ALIVE); break;
           case KW_applied:              GET_FLAG (this, FLAG_APPLIED); break;
           case KW_unpaid:               GET_FLAG (this, FLAG_UNPAID); break;
+          case KW_player_sold:          GET_FLAG (this, FLAG_PLAYER_SOLD); break;
           case KW_is_animated:          GET_FLAG (this, FLAG_ANIMATE); break;
           case KW_no_pick:              GET_FLAG (this, FLAG_NO_PICK); break;
           case KW_reflecting:           GET_FLAG (this, FLAG_REFLECTING); break;
           case KW_changing:             GET_FLAG (this, FLAG_CHANGING); break;
           case KW_splitting:            GET_FLAG (this, FLAG_SPLITTING); break;
             f.next ();
             return true;
           case KW_ERROR:
-            set_ob_key_value (this, f.kw_str, f.value, true);
+            // 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
+            {
+              key_value *kv = new key_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))
   assert (arch); //D maybe use exception handling of sorts?
   f.next ();
-  object *op = object::create ();
+  object *op = arch->instance ();
   op->map = map;
-  arch->copy_to (op);
-  // copy_to activates, this should be fixed properly
+  // instance() activates, this should be fixed properly
   op->deactivate ();
   if (!op->parse_kv (f))
     {
       op->destroy (true);
     /* 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)
+  for (key_value *kv = op->key_values; kv; kv = kv->next)
-    {
+    if (!tmp->key_values || tmp->kv (kv->key) != kv->value)
-      /* Find the field in the opposing member. */
+      f.put (kv->key, kv->value);
-      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.
    */
   CMP_OUT (name);
   CMP_OUT (name_pl);
   CMP_OUT (custom_name);
   CMP_OUT (title);
   CMP_OUT (race);
+  CMP_OUT (skill);
   CMP_OUT (slaying);
   CMP_OUT (tag);
   CMP_OUT (other_arch);
   if (op->msg  != tmp->msg ) f.put (KW_msg , KW_endmsg , op->msg );
   CMP_OUT (direction);
   CMP_OUT (type);
   CMP_OUT (subtype);
   CMP_OUT (attacktype);
-  for (i = 0; i < NROFATTACKS; i++)
+  for (int i = 0; i < NROFATTACKS; i++)
     if (expect_false (op->resist[i] != tmp->resist[i]))
       f.put (resist_save[i], op->resist[i]);
   CMP_OUT (path_attuned);
   CMP_OUT (path_repelled);
   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)))
+  if (op->flag [FLAG_IS_LINKED])
+    if (int i = get_button_value (op))
-    f.put (KW_connected, i);
+      f.put (KW_connected, i);
   CMP_OUT (randomitems);
   CMP_OUT2 (container, weight_limit);
   CMP_OUT (run_away);
   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++)
+    for (int i = 0; i <= NUM_FLAGS; i++)
       if (expect_false (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++)
+  for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
     if (expect_false (op->slot[i].info != tmp->slot[i].info))
       f.put (body_locations[i].save_name, op->slot[i].info);
 }
 /*
  * the only place this is not set is when saving the player.
  */
 bool
 object::write (object_freezer &f)
 {
-  archetype *at = arch ? (archetype *)arch : empty_archetype;
+  archetype *at = arch ? arch : archetype::empty;
   f.put (KW_arch, at->archname);
   write_diff (f, this, at);
   for (object *tmp = inv; tmp; tmp = tmp->below)
 /////////////////////////////////////////////////////////////////////////////
 // generic resource file load,
 // currently supports: region, treasures, archetypes
+bool
-bool load_resource_file (const char *filename)
+load_resource_file_ (const char *filename)
 {
   object_thawer f (filename);
-  bool success   = false;
-  bool seen_arch = false;
   for (;;)
     {
       switch (f.kw)
         {
           case KW_region:
             if (!region::read (f))
-              goto finish;
+              return false;
             break;
           case KW_treasure:
           case KW_treasureone:
             if (!treasurelist::read (f))
-              goto finish;
+              return false;
             break;
           case KW_object:
-            seen_arch = true;
             if (!archetype::read (f))
-              goto finish;
+              return false;
             break;
           case KW_EOF:
-            success = true;
+            return true;
-            goto finish;
           default:
             if (!f.parse_error ("resource file"))
-              goto finish;
+              return false;
             f.next ();
             break;
         }
     }
-finish:
-  if (seen_arch)
-    init_archetype_pointers ();
-  return success;
 }

Diff Legend

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

Comparing deliantra/server/common/loader.C (file contents): Revision 1.107 by root, Fri Apr 11 14:09:56 2008 UTC vs. Revision 1.114 by root, Sat May 3 11:14:50 2008 UTC

Diff Legend

Comparing deliantra/server/common/loader.C (file contents):
Revision 1.107 by root, Fri Apr 11 14:09:56 2008 UTC vs.
Revision 1.114 by root, Sat May 3 11:14:50 2008 UTC