--- deliantra/server/common/object.C	2007/01/15 21:06:18	1.116
+++ deliantra/server/common/object.C	2007/04/16 06:23:40	1.137
@@ -359,7 +359,6 @@
  *      Some error messages.
  * The result of the dump is stored in the static global errmsg array.
  */
-
 char *
 dump_object (object *op)
 {
@@ -367,7 +366,7 @@
     return strdup ("[NULLOBJ]");
 
   object_freezer freezer;
-  save_object (freezer, op, 1);
+  op->write (freezer);
   return freezer.as_string ();
 }
 
@@ -457,7 +456,7 @@
 static void
 free_key_values (object *op)
 {
-  for (key_value *i = op->key_values; i != 0;)
+  for (key_value *i = op->key_values; i; )
     {
       key_value *next = i->next;
       delete i;
@@ -468,40 +467,24 @@
   op->key_values = 0;
 }
 
-/*
- * copy_to first frees everything allocated by the dst object,
- * and then copies the contents of itself into the second
- * object, allocating what needs to be allocated.  Basically, any
- * data that is malloc'd needs to be re-malloc/copied.  Otherwise,
- * if the first object is freed, the pointers in the new object
- * will point at garbage.
- */
-void
-object::copy_to (object *dst)
+object &
+object::operator =(const object &src)
 {
-  bool is_freed   = QUERY_FLAG (dst, FLAG_FREED);
-  bool is_removed = QUERY_FLAG (dst, FLAG_REMOVED);
-
-  *(object_copy *)dst = *this;
+  bool is_freed   = flag [FLAG_FREED];
+  bool is_removed = flag [FLAG_REMOVED];
 
-  if (is_freed)
-    SET_FLAG (dst, FLAG_FREED);
+  *(object_copy *)this = src;
 
-  if (is_removed)
-    SET_FLAG (dst, FLAG_REMOVED);
-
-  if (speed < 0)
-    dst->speed_left = speed_left - RANDOM () % 200 / 100.0;
+  flag [FLAG_FREED]   = is_freed;
+  flag [FLAG_REMOVED] = is_removed;
 
   /* Copy over key_values, if any. */
-  if (key_values)
+  if (src.key_values)
     {
       key_value *tail = 0;
-      key_value *i;
+      key_values = 0;
 
-      dst->key_values = 0;
-
-      for (i = key_values; i; i = i->next)
+      for (key_value *i = src.key_values; i; i = i->next)
         {
           key_value *new_link = new key_value;
 
@@ -510,9 +493,9 @@
           new_link->value = i->value;
 
           /* Try and be clever here, too. */
-          if (!dst->key_values)
+          if (!key_values)
             {
-              dst->key_values = new_link;
+              key_values = new_link;
               tail = new_link;
             }
           else
@@ -522,10 +505,45 @@
             }
         }
     }
+}
+
+/*
+ * copy_to first frees everything allocated by the dst object,
+ * and then copies the contents of itself into the second
+ * object, allocating what needs to be allocated.  Basically, any
+ * data that is malloc'd needs to be re-malloc/copied.  Otherwise,
+ * if the first object is freed, the pointers in the new object
+ * will point at garbage.
+ */
+void
+object::copy_to (object *dst)
+{
+  *dst = *this;
+
+  if (speed < 0)
+    dst->speed_left = speed_left - rndm ();
 
   dst->set_speed (dst->speed);
 }
 
+void
+object::instantiate ()
+{
+  if (!uuid.seq) // HACK
+    uuid = gen_uuid ();
+
+  speed_left = -0.1f;
+  /* copy the body_info to the body_used - this is only really
+   * need for monsters, but doesn't hurt to do it for everything.
+   * by doing so, when a monster is created, it has good starting
+   * values for the body_used info, so when items are created 
+   * for it, they can be properly equipped.
+   */
+  memcpy (body_used, body_info, sizeof (body_used));
+
+  attachable::instantiate ();
+}
+
 object *
 object::clone ()
 {
@@ -591,8 +609,6 @@
 void
 update_object (object *op, int action)
 {
-  MoveType move_on, move_off, move_block, move_slow;
-
   if (op == NULL)
     {
       /* this should never happen */
@@ -672,6 +688,8 @@
 
 object::~object ()
 {
+  unlink ();
+
   free_key_values (this);
 }
 
@@ -689,7 +707,9 @@
 
 void object::unlink ()
 {
-  assert (index);//D
+  if (!index)
+    return;
+
   objects.erase (this);
   refcnt_dec ();
 }
@@ -773,6 +793,7 @@
   if (!drop_to_ground
       || !map
       || map->in_memory != MAP_IN_MEMORY
+      || map->nodrop
       || ms ().move_block == MOVE_ALL)
     {
       while (inv)
@@ -816,7 +837,15 @@
     remove_button_link (this);
 
   if (flag [FLAG_FRIENDLY])
-    remove_friendly_object (this);
+    {
+      remove_friendly_object (this);
+
+      if (type == GOLEM
+          && owner
+          && owner->type == PLAYER
+          && owner->contr->ranges[range_golem] == this)
+        owner->contr->ranges[range_golem] = 0;
+    }
 
   if (!flag [FLAG_REMOVED])
     remove ();
@@ -898,10 +927,9 @@
  *   object will have no environment.  If the object previously had an
  *   environment, the x and y coordinates will be updated to
  *   the previous environment.
- *   Beware: This function is called from the editor as well!
  */
 void
-object::remove ()
+object::do_remove ()
 {
   object *tmp, *last = 0;
   object *otmp;
@@ -954,17 +982,24 @@
     {
       if (type == PLAYER)
         {
+          // leaving a spot always closes any open container on the ground
+          if (container && !container->env)
+            // this causes spurious floorbox updates, but it ensures
+            // that the CLOSE event is being sent.
+            close_container ();
+
           --map->players;
           map->touch ();
         }
 
       map->dirty = true;
+      mapspace &ms = this->ms ();
 
       /* link the object above us */
       if (above)
         above->below = below;
       else
-        map->at (x, y).top = below;       /* we were top, set new top */
+        ms.top = below;       /* we were top, set new top */
 
       /* Relink the object below us, if there is one */
       if (below)
@@ -976,17 +1011,9 @@
            * evident
            */
           if (GET_MAP_OB (map, x, y) != this)
-            {
-              char *dump = dump_object (this);
-              LOG (llevError,
-                   "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom?\n%s\n", dump);
-              free (dump);
-              dump = dump_object (GET_MAP_OB (map, x, y));
-              LOG (llevError, "%s\n", dump);
-              free (dump);
-            }
+            LOG (llevError, "remove_ob: GET_MAP_OB does not return object to be removed even though it appears to be on the bottom? %s\n", debug_desc ());
 
-          map->at (x, y).bot = above;      /* goes on above it. */
+          ms.bot = above;      /* goes on above it. */
         }
 
       above = 0;
@@ -997,7 +1024,7 @@
 
       int check_walk_off = !flag [FLAG_NO_APPLY];
 
-      for (tmp = map->at (x, y).bot; tmp; tmp = tmp->above)
+      for (tmp = ms.bot; tmp; tmp = tmp->above)
         {
           /* No point updating the players look faces if he is the object
            * being removed.
@@ -1088,8 +1115,8 @@
 }
 
 /*
- * same as insert_ob_in_map except it handle separate coordinates and do a clean
- * job preparing multi-part monsters
+ * same as insert_ob_in_map except it handles separate coordinates and does a clean
+ * job preparing multi-part monsters.
  */
 object *
 insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
@@ -1127,7 +1154,6 @@
 insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
 {
   object *tmp, *top, *floor = NULL;
-  sint16 x, y;
 
   if (QUERY_FLAG (op, FLAG_FREED))
     {
@@ -1135,6 +1161,11 @@
       return NULL;
     }
 
+  if (!QUERY_FLAG (op, FLAG_REMOVED))
+    LOG (llevError, "Trying to insert already inserted object %s\n", op->debug_desc ());
+
+  op->remove ();
+
   if (!m)
     {
       char *dump = dump_object (op);
@@ -1158,36 +1189,9 @@
       return op;
     }
 
-  if (!QUERY_FLAG (op, FLAG_REMOVED))
+  if (object *more = op->more)
     {
-      char *dump = dump_object (op);
-      LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", dump);
-      free (dump);
-      return op;
-    }
-
-  if (op->more)
-    {
-      /* The part may be on a different map. */
-
-      object *more = op->more;
-
-      /* We really need the caller to normalise coordinates - if
-       * we set the map, that doesn't work if the location is within
-       * a map and this is straddling an edge.  So only if coordinate
-       * is clear wrong do we normalise it.
-       */
-      if (OUT_OF_REAL_MAP (more->map, more->x, more->y))
-        more->map = get_map_from_coord (m, &more->x, &more->y);
-      else if (!more->map)
-        {
-          /* For backwards compatibility - when not dealing with tiled maps,
-           * more->map should always point to the parent.
-           */
-          more->map = m;
-        }
-
-      if (insert_ob_in_map (more, more->map, originator, flag) == NULL)
+      if (!insert_ob_in_map (more, m, originator, flag))
         {
           if (!op->head)
             LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
@@ -1202,14 +1206,16 @@
    * of areas of callers (eg, anything that uses find_free_spot would now
    * need extra work
    */
-  op->map = get_map_from_coord (m, &op->x, &op->y);
-  x = op->x;
-  y = op->y;
+  if (!xy_normalise (m, op->x, op->y))
+    return 0;
+
+  op->map = m;
+  mapspace &ms = op->ms ();
 
   /* this has to be done after we translate the coordinates.
    */
   if (op->nrof && !(flag & INS_NO_MERGE))
-    for (tmp = GET_MAP_OB (op->map, x, y); tmp; tmp = tmp->above)
+    for (tmp = ms.bot; tmp; tmp = tmp->above)
       if (object::can_merge (op, tmp))
         {
           op->nrof += tmp->nrof;
@@ -1236,15 +1242,17 @@
       if (op->below)
         op->below->above = op;
       else
-        op->ms ().bot = op;
+        ms.bot = op;
 
       /* since *below* originator, no need to update top */
       originator->below = op;
     }
   else
     {
+      top = ms.bot;
+
       /* If there are other objects, then */
-      if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))
+      if ((!(flag & INS_MAP_LOAD)) && top)
         {
           object *last = 0;
 
@@ -1260,7 +1268,7 @@
            * when lots of spells are cast in one area.  Currently, it is presumed
            * that flying non pickable objects are spell objects.
            */
-          while (top)
+          for (top = ms.bot; top; top = top->above)
             {
               if (QUERY_FLAG (top, FLAG_IS_FLOOR) || QUERY_FLAG (top, FLAG_OVERLAY_FLOOR))
                 floor = top;
@@ -1273,7 +1281,6 @@
                 }
 
               last = top;
-              top = top->above;
             }
 
           /* Don't want top to be NULL, so set it to the last valid object */
@@ -1285,17 +1292,19 @@
            */
 
           /* Have object 'fall below' other objects that block view.
-           * Unless those objects are exits, type 66
+           * Unless those objects are exits.
            * If INS_ON_TOP is used, don't do this processing
            * Need to find the object that in fact blocks view, otherwise
            * stacking is a bit odd.
            */
-          if (!(flag & INS_ON_TOP) &&
-              (get_map_flags (op->map, 0, op->x, op->y, 0, 0) & P_BLOCKSVIEW) && (op->face && !op->face->visibility))
+          if (!(flag & INS_ON_TOP)
+              && ms.flags () & P_BLOCKSVIEW
+              && (op->face && !faces [op->face].visibility))
             {
               for (last = top; last != floor; last = last->below)
                 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
                   break;
+
               /* Check to see if we found the object that blocks view,
                * and make sure we have a below pointer for it so that
                * we can get inserted below this one, which requires we
@@ -1307,7 +1316,7 @@
         }                       /* If objects on this space */
 
       if (flag & INS_MAP_LOAD)
-        top = GET_MAP_TOP (op->map, op->x, op->y);
+        top = ms.top;
 
       if (flag & INS_ABOVE_FLOOR_ONLY)
         top = floor;
@@ -1318,13 +1327,13 @@
       /* First object on this space */
       if (!top)
         {
-          op->above = GET_MAP_OB (op->map, op->x, op->y);
+          op->above = ms.bot;
 
           if (op->above)
             op->above->below = op;
 
           op->below = 0;
-          op->ms ().bot = op;
+          ms.bot = op;
         }
       else
         {                       /* get inserted into the stack above top */
@@ -1338,7 +1347,7 @@
         }
 
       if (!op->above)
-        op->ms ().top = op;
+        ms.top = op;
     }                           /* else not INS_BELOW_ORIGINATOR */
 
   if (op->type == PLAYER)
@@ -1354,7 +1363,7 @@
    * it, so save a few ticks and start from there.
    */
   if (!(flag & INS_MAP_LOAD))
-    if (object *pl = op->ms ().player ())
+    if (object *pl = ms.player ())
       if (pl->contr->ns)
         pl->contr->ns->floorbox_update ();
 
@@ -1423,6 +1432,7 @@
   insert_ob_in_map (tmp1, op->map, op, 0);
 }
 
+// XXX: function not returning object*
 object *
 object::insert_at (object *where, object *originator, int flags)
 {
@@ -1773,7 +1783,7 @@
             {
 
               float
-                diff = tmp->move_slow_penalty * FABS (op->speed);
+                diff = tmp->move_slow_penalty * fabs (op->speed);
 
               if (op->type == PLAYER)
                 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
@@ -1990,7 +2000,7 @@
   if (!index)
     return -1;
 
-  return altern[RANDOM () % index];
+  return altern [rndm (index)];
 }
 
 /*
@@ -2021,7 +2031,7 @@
   end -= begin;
 
   while (--end)
-    swap (arr [end], arr [RANDOM () % (end + 1)]);
+    swap (arr [end], arr [rndm (end + 1)]);
 }
 
 /* new function to make monster searching more efficient, and effective! 
@@ -2343,44 +2353,6 @@
   return dst;
 }
 
-/* GROS - Creates an object using a string representing its content.         */
-/* Basically, we save the content of the string to a temp file, then call    */
-/* load_object on it. I admit it is a highly inefficient way to make things, */
-/* but it was simple to make and allows reusing the load_object function.    */
-/* Remember not to use load_object_str in a time-critical situation.         */
-/* Also remember that multiparts objects are not supported for now.          */
-object *
-load_object_str (const char *obstr)
-{
-  object *op;
-  char filename[MAX_BUF];
-
-  sprintf (filename, "%s/cfloadobstr2044", settings.tmpdir);
-
-  FILE *tempfile = fopen (filename, "w");
-
-  if (tempfile == NULL)
-    {
-      LOG (llevError, "Error - Unable to access load object temp file\n");
-      return NULL;
-    }
-
-  fprintf (tempfile, obstr);
-  fclose (tempfile);
-
-  op = object::create ();
-
-  object_thawer thawer (filename);
-
-  if (thawer)
-    load_object (thawer, op, 0);
-
-  LOG (llevDebug, " load str completed, object=%s\n", &op->name);
-  CLEAR_FLAG (op, FLAG_REMOVED);
-
-  return op;
-}
-
 /* This returns the first object in who's inventory that
  * has the same type and subtype match.
  * returns NULL if no match.
@@ -2444,7 +2416,6 @@
   return 0;
 }
 
-
 /*
  * Updates the canonical_key in op to value.
  *
@@ -2593,10 +2564,10 @@
   char info2[256 * 4];
   char *p = info;
 
-  p += snprintf (p, 512, "{cnt:%d,uuid:<1,%" PRIx64 ">,name:\"%s%s%s\",flags:[%s],type:%d}",
+  p += snprintf (p, 512, "{cnt:%d,uuid:<1.%" PRIx64 ">,name:\"%s\"%s%s,flags:[%s],type:%d}",
                  count, uuid.seq,
                  &name,
-                 title ? "\",title:" : "",
+                 title ? "\",title:\"" : "",
                  title ? (const char *)title : "",
                  flag_desc (flagdesc, 512), type);
 
@@ -2623,3 +2594,74 @@
   return debug_desc (info);
 }
 
+struct region *
+object::region () const
+{
+  return map ? map->region (x, y)
+             : region::default_region ();
+}
+
+const materialtype_t *
+object::dominant_material () const
+{
+  if (materialtype_t *mat = name_to_material (materialname))
+    return mat;
+
+  // omfg this is slow, this has to be temporary :)
+  shstr unknown ("unknown");
+
+  return name_to_material (unknown);
+}
+
+void
+object::open_container (object *new_container)
+{
+  if (container == new_container)
+    return;
+
+  if (object *old_container = container)
+    {
+      if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this)))
+        return;
+
+#if 0
+      // remove the "Close old_container" object.
+      if (object *closer = old_container->inv)
+        if (closer->type == CLOSE_CON)
+          closer->destroy ();
+#endif
+
+      old_container->flag [FLAG_APPLIED] = 0;
+      container = 0;
+
+      esrv_update_item (UPD_FLAGS, this, old_container);
+      new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
+    }
+
+  if (new_container)
+    {
+      if (INVOKE_OBJECT (OPEN, new_container, ARG_OBJECT (this)))
+        return;
+
+      // TODO: this does not seem to serve any purpose anymore?
+#if 0
+      // insert the "Close Container" object.
+      if (archetype *closer = new_container->other_arch)
+        {
+          object *closer = arch_to_object (new_container->other_arch);
+          closer->flag [FLAG_NO_MAP_SAVE] = 1;
+          new_container->insert (closer);
+        }
+#endif
+
+      new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container));
+
+      new_container->flag [FLAG_APPLIED] = 1;
+      container = new_container;
+
+      esrv_update_item (UPD_FLAGS, this, new_container);
+      esrv_send_inventory (this, new_container);
+    }
+}
+
+