--- deliantra/server/common/arch.C	2007/04/16 11:09:30	1.48
+++ deliantra/server/common/arch.C	2007/04/19 19:24:25	1.57
@@ -311,9 +311,11 @@
 overwrite (archetype *at, object *op)
 {
   at->clone = *op;
-  
   at->clone.arch = at;
-  //TODO: inv et al.
+
+  at->clone.inv = op->inv; op->inv = 0;
+
+  op->destroy ();
 }
 
 archetype *
@@ -321,120 +323,134 @@
 {
   assert (f.kw == KW_object);
 
-  archetype *head = get (f.get_str ());
-  unlink (head);
-  object *op = object::create ();
+  loading_arch = true; // hack to tell parse_kv et al. to behave
 
-  if (!op->parse_kv (f))
-    {
-      op->destroy (true);
-      // leak head
-      return 0;
-    }
+  typedef std::pair<archetype *, object *> part;
+  std::vector<part> parts;
 
-  overwrite (head, op);
-  op->destroy ();
+  coroapi::cede_to_tick_every (100);
 
-  for (archetype *prev = head; f.kw == KW_more; )
+  for (;;)
     {
-      f.next ();
-      assert (f.kw == KW_object);
-
-      archetype *more = get (f.get_str ());
-      unlink (more);
       object *op = object::create ();
+      archetype *at = get (f.get_str ());
+      f.get (op->name);
+      f.next ();
 
-      if (!op->parse_kv (f))
+#if 0
+      if (f.kw == KW_inherit)
         {
-          op->destroy (true);
-          // leak head more*
-          return 0;
-        }
+          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 ());
 
-      overwrite (more, op);
-      op->destroy ();
-
-      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;
+          f.next ();
+        }
+#endif
 
-      more->head       = head;
-      more->clone.head = &head->clone;
-      prev->more       = more;
-      prev->clone.more = &more->clone;
+      if (!op->parse_kv (f))
+        goto fail;
 
-      prev = more;
-    }
+      parts.push_back (std::make_pair (at, op));
 
-  if (!head->next)
-    {
-      head->next = first_archetype;
-      first_archetype = head;
-    }
+      if (f.kw != KW_more)
+        break;
 
-  return head;
-}
+      f.next ();
 
-/*
- * 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)
+      if (f.kw != KW_object)
         {
-          case KW_object:
-            loading_arch = true;
-            if (!archetype::read (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.parse_error ("more object");
+          goto fail;
         }
-
-        f.next ();
     }
-}
-
-/*
- * First initialises the archtype hash-table (init_archetable()).
- * Reads and parses the archetype file (with the first and second-pass
- * functions).
- */
-bool
-load_archetype_file (const char *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))
-    return false;
-
-  warn_archetypes = 1;
+  {
+    archetype *head = parts.front ().first;
 
+    // check that all archetypes belong to the same object or are heads
+    for (auto (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->linked)
+      {
+        head->linked = true;
+        head->next = first_archetype;
+        first_archetype = head;
+      }
+
+    // reassemble new chain
+    archetype *prev = head;
+    for (auto (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;
+      }
+
+    loading_arch = false;
+    return head;
+  }
+
+fail:
+  for (auto (p, parts.begin ()); p != parts.end (); ++p)
+    p->second->destroy (true);
+
+  loading_arch = false;
+  return 0;
+}
+
+/*
+ * Initialize global archtype pointers:
+ */
+void
+init_archetype_pointers ()
+{
+  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;
-
-  coroapi::cede ();
-
-  return true;
 }
 
 /*
@@ -446,15 +462,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;
 }
 
@@ -493,36 +508,6 @@
 }
 
 /*
- * Hash-function used by the arch-hashtable.
- */
-
-unsigned long
-hasharch (const char *str, int tablesize)
-{
-  unsigned long hash = 0;
-  unsigned int i = 0;
-  const char *p;
-
-  /* use the one-at-a-time hash function, which supposedly is
-   * better than the djb2-like one used by perl5.005, but
-   * certainly is better then the bug used here before.
-   * see http://burtleburtle.net/bob/hash/doobs.html
-   */
-  for (p = str; i < MAXSTRING && *p; p++, i++)
-    {
-      hash += *p;
-      hash += hash << 10;
-      hash ^= hash >> 6;
-    }
-
-  hash += hash << 3;
-  hash ^= hash >> 11;
-  hash += hash << 15;
-
-  return hash % tablesize;
-}
-
-/*
  * Finds, using the hashtable, which archetype matches the given name.
  * returns a pointer to the found archetype, otherwise NULL.
  */
@@ -532,7 +517,7 @@
   if (!name)
     return 0;
 
-  AUTODECL (i, ht.find (name));
+  auto (i, ht.find (name));
 
   if (i == ht.end ())
     return 0;
@@ -548,7 +533,7 @@
   if (!at)
     {
       archetypes.push_back (at = new archetype);
-      at->name = name;
+      at->name = at->clone.name = at->clone.name_pl = name;
       at->hash_add ();
     }