--- deliantra/server/common/arch.C	2007/04/16 10:14:25	1.47
+++ deliantra/server/common/arch.C	2007/06/04 13:04:00	1.63
@@ -1,25 +1,25 @@
 /*
- * CrossFire, A Multiplayer game for X-windows
+ * This file is part of Crossfire TRT, the Multiplayer Online Role Playing Game.
  * 
- * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
- * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
- * Copyright (C) 1992 Frank Tore Johansen
+ * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
+ * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
+ * Copyright (©) 1992,2007 Frank Tore Johansen
  * 
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
+ * Crossfire TRT is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 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.
+ * 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 GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * The authors can be reached via e-mail at <crossfire@schmorp.de>
+ * You should have received a copy of the GNU General Public License along
+ * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ * 
+ * The authors can be reached via e-mail to <crossfire@schmorp.de>
  */
 
 #include <cassert>
@@ -52,7 +52,7 @@
   > HT;
 
 static HT ht (5000);
-static std::vector<archetype *> archetypes;
+archvec archetypes;
 
 /**
  * GROS -  This function retrieves an archetype given the name that appears
@@ -70,8 +70,8 @@
 {
   shstr_cmp name_cmp (name);
 
-  for (archetype *at = first_archetype; at; at = at->next)
-    if (at->clone.name == name_cmp)
+  for_all_archetypes (at)
+    if (at->archname == name_cmp)
       return at;
 
   return 0;
@@ -87,8 +87,8 @@
 {
   shstr_cmp name_cmp (name);
 
-  for (archetype *at = first_archetype; at; at = at->next)
-    if (at->clone.name == name_cmp && at->clone.type == type)
+  for_all_archetypes (at)
+    if (at->archname == name_cmp && at->type == type)
       return at;
 
   return 0;
@@ -104,8 +104,8 @@
 {
   shstr_cmp skill_cmp (skill);
 
-  for (archetype *at = first_archetype; at; at = at->next)
-    if (at->clone.skill == skill_cmp && (type == -1 || type == at->clone.type))
+  for_all_archetypes (at)
+    if (at->skill == skill_cmp && (type == -1 || type == at->type))
       return arch_to_object (at);
 
   return 0;
@@ -121,8 +121,8 @@
 archetype *
 get_archetype_by_type_subtype (int type, int subtype)
 {
-  for (archetype *at = first_archetype; at; at = at->next)
-    if ((type == -1 || type == at->clone.type) && (subtype == -1 || subtype == at->clone.subtype))
+  for_all_archetypes (at)
+    if ((type == -1 || type == at->type) && (subtype == -1 || subtype == at->subtype))
       return at;
 
   return 0;
@@ -277,51 +277,78 @@
   return 0;
 }
 
+archetype::archetype (const char *name)
+{
+  stub = true;
+  arch = this;
+  this->archname = this->name = this->name_pl = name;
+}
+
+archetype::~archetype ()
+{
+  unlink ();
+}
+
 void
-init_archetypes (void)
+archetype::link ()
 {
-  load_archetypes ();
+  ht.insert (std::make_pair (archname, this));
 
-  empty_archetype = archetype::find ("empty_archetype");
+  if (!archetypes.contains (this))
+    archetypes.insert (this);
 }
 
-archetype::archetype ()
+void
+archetype::unlink ()
 {
-  clone.arch = this;
+  ht.erase (archname);
 
-  CLEAR_FLAG (&clone, FLAG_FREED);      /* This shouldn't matter, since copy_to */
-  SET_FLAG (&clone, FLAG_REMOVED);      /* doesn't copy these flags... */
+  if (archetypes.contains (this))
+    archetypes.erase (this);
 }
 
-archetype::~archetype ()
+/*
+ * Finds, using the hashtable, which archetype matches the given name.
+ * returns a pointer to the found archetype, otherwise NULL.
+ */
+archetype *
+archetype::find (const char *name)
 {
-  //TODO: nuke ->more's
+  if (!name)
+    return 0;
+
+  auto (i, ht.find (name));
+
+  if (i == ht.end ())
+    return 0;
+  else
+    return i->second;
 }
 
-static void
-unlink (archetype *at)
+archetype *
+archetype::get (const char *name)
 {
-  if (at->head)
-    at = at->head;
+  if (!name)
+    {
+      LOG (llevError, "null archetype requested\n");
+      name = "(null)";
+    }
 
-  // destroy this archetype's link, making singletons out of its parts
-  while (at)
+  archetype *at = find (name);
+
+  if (loading_arch && at && !at->stub)
     {
-      archetype *more = at->more;
-      at->clone.destroy_inv ();
-      at->head = at->more = 0;
-      at = more;
+      at->unlink ();
+      at = 0;
     }
-}
 
-// dire hack, need to rationalise
-void
-overwrite (archetype *at, object *op)
-{
-  at->clone = *op;
-  
-  at->clone.arch = at;
-  //TODO: inv et al.
+  if (!at || (!at->stub && loading_arch))
+    {
+      at = new archetype (name);
+      at->link ();
+    }
+
+  return at;
 }
 
 archetype *
@@ -329,116 +356,141 @@
 {
   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;
-    }
+  std::vector<archetype *> parts;
 
-  overwrite (head, op);
-  op->destroy ();
+  coroapi::cede_to_tick_every (10);
 
-  for (archetype *prev = head; f.kw == KW_more; )
+  for (;;)
     {
-      f.next ();
-      assert (f.kw == KW_object);
+      // the archetype might have been referenced earlier
+      // so try to find an existing stub archetype first
+      archetype *at = find (f.get_str ());
 
-      archetype *more = get (f.get_str ());
-      unlink (more);
-      object *op = object::create ();
+      if (!at || !at->stub)
+        at = new archetype (f.get_str ());
 
-      if (!op->parse_kv (f))
+      f.next ();
+
+#if 0
+      // implementing it here in the server does neither allow multiple inheritence
+      // nor does it cleanly "just override". it would allow use in map files, though,
+      // and other resource files dynamically laoded (as opposed to being preprocessed).
+      // not that any of this is relevant as of yet...
+      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->archname, f.get_str ());
 
-      overwrite (more, op);
-      op->destroy ();
+          f.next ();
+        }
+#endif
 
-      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 (!at->parse_kv (f))
+        goto fail;
 
-      more->head       = head;
-      more->clone.head = &head->clone;
-      prev->more       = more;
-      prev->clone.more = &more->clone;
+      at->post_load_check ();
 
-      prev = more;
-    }
+      parts.push_back (at);
 
-  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).
- */
-void
-load_archetypes (void)
-{
-  char filename[MAX_BUF];
 
-  sprintf (filename, "%s/%s", settings.datadir, settings.archetypes);
-  LOG (llevDebug, "Reading archetypes from %s:\n", filename);
+  loading_arch = false;
 
-  object_thawer f (filename);
+  {
+    auto (at, parts.begin ());
 
-  f.next ();
+    archetype *new_head = parts.front ();
+    archetype *old_head = find (new_head->archname);
 
-  if (!load_archetypes (f))
-    cleanup ("unable to load archetypes");
+    for (auto (at, parts.begin ()); at != parts.end (); ++at)
+      fprintf (stderr, "%d: %s\n", at - parts.begin(), &(*at)->archname);//D
+
+    // check that all archetypes belong to the same old object or are new
+    for (auto (at, parts.begin ()); at != parts.end (); ++at)
+      {
+        archetype *new_part = *at;
+        archetype *old_part = find (new_part->archname);
+
+        if (old_part && old_part->head_ () != old_head)
+          {
+            fprintf (stderr, "nhn %s\n", &new_head->archname);//D
+            fprintf (stderr, "old_head %p,%p new_head %p,%p ph %p\n", old_head, old_part, new_head, new_part, old_part->head_());
+            LOG (llevError, "%s: unable to overwrite archetype '%s' with archetype of different object, skipping.\n",
+                 &new_part->archname, &((archetype *)old_part->head_ ())->archname);
+            goto fail;
+          }
+      }
+
+    fprintf (stderr, "oh %p %s\n", old_head, &new_head->archname);//D
+
+    // deactivate existing archetype
+    for (archetype *at = old_head; at; at = (archetype *)at->more)
+      at->unlink ();
+
+    // reassemble new chain
+    new_head->min_x = new_head->max_x = new_head->x;
+    new_head->min_y = new_head->max_y = new_head->y;
+
+    archetype *less = new_head;
+    archetype *head = 0;
+    for (auto (p, parts.begin () + 1); p != parts.end (); ++p)
+      {
+        archetype *at = *p;
+
+        if (at->x < new_head->min_x) new_head->min_x = at->x;
+        if (at->y < new_head->min_y) new_head->min_y = at->y;
+        if (at->x > new_head->max_x) new_head->max_x = at->x;
+        if (at->y > new_head->max_y) new_head->max_y = at->y;
+
+        at->head   = head; head = new_head;
+        less->more = at;   less = at;
+      }
+
+    // now activate it
+    for (auto (p, parts.begin ()); p != parts.end (); ++p)
+      {
+        archetype *at = *p;
+        at->stub = false;
+        at->link ();
+      }
+
+    return new_head;
+  }
+
+fail:
+  for (auto (p, parts.begin ()); p != parts.end (); ++p)
+    (*p)->destroy (true);
 
-  warn_archetypes = 1;
+  loading_arch = false;
+  return 0;
+}
 
-  load_treasures ();
+/*
+ * 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");
 }
 
 /*
@@ -450,15 +502,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 ();
+  object *op = at->clone ();
   op->arch = at;
   op->instantiate ();
+
   return op;
 }
 
@@ -497,92 +548,14 @@
 }
 
 /*
- * 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.
- */
-archetype *
-archetype::find (const char *name)
-{
-  if (!name)
-    return 0;
-
-  AUTODECL (i, ht.find (name));
-
-  if (i == ht.end ())
-    return 0;
-  else
-    return i->second;
-}
-
-archetype *
-archetype::get (const char *name)
-{
-  archetype *at = find (name);
-
-  if (!at)
-    {
-      archetypes.push_back (at = new archetype);
-      at->name = name;
-      at->hash_add ();
-    }
-
-  return at;
-}
-
-/*
- * Adds an archetype to the hashtable.
- */
-void
-archetype::hash_add ()
-{
-  ht.insert (std::make_pair (name, this));
-}
-
-void
-archetype::hash_del ()
-{
-  ht.erase (name);
-}
-
-/*
  * Returns the first archetype using the given type.
  * Used in treasure-generation.
  */
 archetype *
 type_to_archetype (int type)
 {
-  for (archetype *at = first_archetype; at; at = at->more == 0 ? at->next : at->more)
-    if (at->clone.type == type)
+  for_all_archetypes (at)
+    if (at->type == type && at->head_ () != at)
       return at;
 
   return 0;
@@ -604,7 +577,7 @@
       return 0;
     }
 
-  object *op = at->clone.clone ();
+  object *op = at->clone ();
   op->instantiate ();
   return op;
 }
@@ -612,7 +585,6 @@
 /*
  * member: make instance from class
  */
-
 object *
 object_create_arch (archetype *at)
 {
@@ -621,8 +593,9 @@
   while (at)
     {
       op = arch_to_object (at);
-      op->x = at->clone.x;
-      op->y = at->clone.y;
+
+      op->x = at->x;
+      op->y = at->y;
 
       if (head)
         op->head = head, prev->more = op;
@@ -631,9 +604,9 @@
         head = op;
 
       prev = op;
-      at = at->more;
+      at = (archetype *)at->more;
     }
 
-  return (head);
+  return head;
 }