--- deliantra/server/common/arch.C	2007/04/16 06:23:39	1.46
+++ deliantra/server/common/arch.C	2007/04/16 12:37:08	1.49
@@ -277,14 +277,6 @@
   return 0;
 }
 
-void
-init_archetypes (void)
-{
-  load_archetypes ();
-
-  empty_archetype = archetype::find ("empty_archetype");
-}
-
 archetype::archetype ()
 {
   clone.arch = this;
@@ -321,65 +313,104 @@
   at->clone = *op;
   
   at->clone.arch = at;
-  //TODO: inv et al.
+  at->clone.inv = op->inv; op->inv = 0;
+
+  op->destroy ();
 }
 
-archetype *
-archetype::read (object_thawer &f)
+bool
+archetype::load (object_thawer &f)
 {
   assert (f.kw == KW_object);
 
-  archetype *head = get (f.get_str ());
-  unlink (head);
-  object *op = object::create ();
+  typedef std::pair<archetype *, object *> part;
+  std::vector<part> parts;
 
-  if (!op->parse_kv (f))
-    {
-      op->destroy (true);
-      // leak head
-      return 0;
-    }
-
-  overwrite (head, op);
-  op->destroy ();
-
-  for (archetype *prev = head; f.kw == KW_more; )
+  for (;;)
     {
-      f.next ();
-      assert (f.kw == KW_object);
-
-      archetype *more = get (f.get_str ());
-      unlink (more);
+      archetype *at = get (f.get_str ());
       object *op = object::create ();
 
       if (!op->parse_kv (f))
-        {
-          op->destroy (true);
-          // leak head more*
-          return 0;
-        }
+        goto fail;
 
-      overwrite (more, op);
-      op->destroy ();
+      parts.push_back (std::make_pair (at, op));
 
-      if (more->clone.x > head->tail_x) head->tail_x = more->clone.x;
-      if (more->clone.y > head->tail_y) head->tail_y = more->clone.y;
+      if (f.kw != KW_more)
+        break;
 
-      more->head       = head;
-      more->clone.head = &head->clone;
-      prev->more       = more;
-      prev->clone.more = &more->clone;
-
-      prev = more;
+      f.next ();
+      assert (f.kw == KW_object);
     }
 
-  if (!head->next)
-    {
-      head->next = first_archetype;
-      first_archetype = head;
-    }
+  {
+    archetype *head = parts.front ().first;
+
+    // check that all archetypes belong to the same object or are heads
+    for (AUTODECL (p, parts.begin ()); p != parts.end (); ++p)
+      {
+        archetype *at = p->first;
+
+        if (at->head != head && at->head)
+          {
+            LOG (llevError, "%s: unable to overwrite foreign non-head archetype with non-head archetype\n", &at->name);
+            goto fail;
+          }
+
+        if (at->next && at != head)
+          {
+            LOG (llevError, "%s: unable to overwrite foreign head archetype with non-head archetype\n", &at->name);
+            goto fail;
+          }
+      }
+
+    // sever chain of existing head object
+    for (archetype *more, *at = head; at; at = more)
+      {
+        more = at->more;
+
+        at->head = 0;
+        at->more = 0;
+      }
+
+    // replace/update head
+    overwrite (head, parts.front ().second);
+    head->tail_x = 0;
+    head->tail_y = 0;
+
+    // link into list of heads, if not already there
+    if (!head->next)
+      {
+        head->next = first_archetype;
+        first_archetype = head;
+      }
+
+    // reassemble new chain
+    archetype *prev = head;
+    for (AUTODECL (p, parts.begin () + 1); p != parts.end (); ++p)
+      {
+        archetype *at = p->first;
+        overwrite (at, p->second);
+
+        if (at->clone.x > head->tail_x) head->tail_x = at->clone.x;
+        if (at->clone.y > head->tail_y) head->tail_y = at->clone.y;
+
+        at->head         = head;
+        at->clone.head   = &head->clone;
+        prev->more       = at;
+        prev->clone.more = &at->clone;
+
+        prev = at;
+      }
+  }
+
+  return true;
+
+fail:
+  for (AUTODECL (p, parts.begin ()); p != parts.end (); ++p)
+    p->second->destroy (true);
 
-  return head;
+  return false;
 }
 
 /*
@@ -395,7 +426,7 @@
         {
           case KW_object:
             loading_arch = true;
-            if (!archetype::read (f))
+            if (!archetype::load (f))
               {
                 loading_arch = false;
                 return false;
@@ -420,24 +451,29 @@
  * First initialises the archtype hash-table (init_archetable()).
  * Reads and parses the archetype file (with the first and second-pass
  * functions).
- * Then initialises treasures by calling load_treasures().
  */
-void
-load_archetypes (void)
+bool
+load_archetype_file (const char *filename)
 {
-  char filename[MAX_BUF];
-
-  sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
-  LOG (llevDebug, "Reading archetypes from %s:\n", filename);
-
   object_thawer f (filename);
 
   f.next ();
 
+  // make sure the next - long - step is only done after a tick
+  coroapi::wait_for_tick_begin ();
+
   if (!load_archetypes (f))
-    cleanup ("unable to load archetypes");
+    return false;
 
   warn_archetypes = 1;
+
+  empty_archetype = archetype::find ("empty_archetype");
+  if (!empty_archetype)
+    return false;
+
+  coroapi::cede ();
+
+  return true;
 }
 
 /*