--- deliantra/server/common/arch.C	2007/04/17 10:06:32	1.52
+++ deliantra/server/common/arch.C	2007/04/17 19:12:32	1.55
@@ -311,18 +311,20 @@
 overwrite (archetype *at, object *op)
 {
   at->clone = *op;
-  
   at->clone.arch = at;
+
   at->clone.inv = op->inv; op->inv = 0;
 
   op->destroy ();
 }
 
-bool
-archetype::load (object_thawer &f)
+archetype *
+archetype::read (object_thawer &f)
 {
   assert (f.kw == KW_object);
 
+  loading_arch = true; // hack to tell parse_kv et al. to behave
+
   typedef std::pair<archetype *, object *> part;
   std::vector<part> parts;
 
@@ -330,8 +332,21 @@
 
   for (;;)
     {
-      archetype *at = get (f.get_str ());
       object *op = object::create ();
+      archetype *at = get (f.get_str ());
+      f.get (op->name);
+      f.next ();
+
+      if (f.kw == KW_inherit)
+        {
+          if (archetype *at = find (f.get_str ()))
+            *op = at->clone;
+          else
+            LOG (llevError, "archetype '%s' tries to inherit from non-existent archetype '%s'.\n",
+                 &at->name, f.get_str ());
+
+          f.next ();
+        }
 
       if (!op->parse_kv (f))
         goto fail;
@@ -342,7 +357,12 @@
         break;
 
       f.next ();
-      assert (f.kw == KW_object);
+
+      if (f.kw != KW_object)
+        {
+          f.parse_error ("more object");
+          goto fail;
+        }
     }
 
   {
@@ -405,73 +425,30 @@
 
         prev = at;
       }
-  }
 
-  return true;
+    loading_arch = false;
+    return head;
+  }
 
 fail:
   for (auto (p, parts.begin ()); p != parts.end (); ++p)
     p->second->destroy (true);
 
-  return false;
-}
-
-/*
- * Reads/parses the archetype-file, and copies into a linked list
- * of archetype-structures.
- */
-static bool
-load_archetypes (object_thawer &f)
-{
-  for (;;)
-    {
-      switch (f.kw)
-        {
-          case KW_object:
-            loading_arch = true;
-            if (!archetype::load (f))
-              {
-                loading_arch = false;
-                return false;
-              }
-
-            loading_arch = false;
-            continue;
-
-          case KW_EOF:
-            return true;
-
-          default:
-            if (!f.parse_error ("archetypes file"))
-              return false;
-        }
-
-        f.next ();
-    }
+  loading_arch = false;
+  return 0;
 }
 
 /*
- * First initialises the archtype hash-table (init_archetable()).
- * Reads and parses the archetype file (with the first and second-pass
- * functions).
+ * Initialize global archtype pointers:
  */
-bool
-load_archetype_file (const char *filename)
+void
+init_archetype_pointers ()
 {
-  object_thawer f (filename);
-
-  f.next ();
-
-  if (!load_archetypes (f))
-    return false;
-
-  warn_archetypes = 1;
-
+  ring_arch       = archetype::find ("ring");
+  amulet_arch     = archetype::find ("amulet");
+  staff_arch      = archetype::find ("staff");
+  crown_arch      = archetype::find ("crown");
   empty_archetype = archetype::find ("empty_archetype");
-  if (!empty_archetype)
-    return false;
-
-  return true;
 }
 
 /*
@@ -483,15 +460,14 @@
 {
   if (!at)
     {
-      if (warn_archetypes)
-        LOG (llevError, "Couldn't find archetype.\n");
-
-      return NULL;
+      LOG (llevError, "Couldn't find archetype.\n");
+      return 0;
     }
 
   object *op = at->clone.clone ();
   op->arch = at;
   op->instantiate ();
+
   return op;
 }