--- deliantra/server/common/object.C	2007/08/20 18:11:02	1.182
+++ deliantra/server/common/object.C	2007/09/13 16:23:01	1.189
@@ -376,7 +376,6 @@
  * multi-object 1 which is closest to the second object.
  * If it's not a multi-object, it is returned.
  */
-
 object *
 get_nearest_part (object *op, const object *pl)
 {
@@ -431,22 +430,15 @@
 /*
  * Sets the owner and sets the skill and exp pointers to owner's current
  * skill and experience objects.
+ * ACTUALLY NO! investigate! TODO
  */
 void
 object::set_owner (object *owner)
 {
-  if (!owner)
-    return;
-
-  /* next line added to allow objects which own objects */
-  /* Add a check for ownercounts in here, as I got into an endless loop
-   * with the fireball owning a poison cloud which then owned the
-   * fireball.  I believe that was caused by one of the objects getting
-   * freed and then another object replacing it.  Since the ownercounts
-   * didn't match, this check is valid and I believe that cause is valid.
-   */
-  while (owner->owner)
-    owner = owner->owner;
+  // allow objects which own objects
+  if (owner)
+    while (owner->owner)
+      owner = owner->owner;
 
   this->owner = owner;
 }
@@ -588,7 +580,7 @@
   *dst = *this;
 
   if (speed < 0)
-    dst->speed_left = speed_left - rndm ();
+    dst->speed_left -= rndm ();
 
   dst->set_speed (dst->speed);
 }
@@ -925,6 +917,7 @@
       {
         freed_map = new maptile;
 
+        freed_map->path   = "<freed objects map>";
         freed_map->name   = "/internal/freed_objects_map";
         freed_map->width  = 3;
         freed_map->height = 3;
@@ -1240,17 +1233,14 @@
 
   op->remove ();
 
-  if (out_of_map (m, op->x, op->y))
+  /* Ideally, the caller figures this out.  However, it complicates a lot
+   * of areas of callers (eg, anything that uses find_free_spot would now
+   * need extra work
+   */
+  if (!xy_normalise (m, op->x, op->y))
     {
-      LOG (llevError, "Trying to insert object outside the map.\n%s\n", op->debug_desc ());
-#ifdef MANY_CORES
-      /* Better to catch this here, as otherwise the next use of this object
-       * is likely to cause a crash.  Better to find out where it is getting
-       * improperly inserted.
-       */
-      abort ();
-#endif
-      return op;
+      op->destroy ();
+      return 0;
     }
 
   if (object *more = op->more)
@@ -1259,13 +1249,6 @@
 
   CLEAR_FLAG (op, FLAG_REMOVED);
 
-  /* Ideally, the caller figures this out.  However, it complicates a lot
-   * of areas of callers (eg, anything that uses find_free_spot would now
-   * need extra work
-   */
-  if (!xy_normalise (m, op->x, op->y))
-    return 0;
-
   op->map = m;
   mapspace &ms = op->ms ();
 
@@ -2015,9 +1998,22 @@
 
   for (int i = start; i < stop; i++)
     {
-      flag = ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]);
-      if (!flag)
-        altern [index++] = i;
+      mapxy pos (m, x, y); pos.move (i);
+
+      if (!pos.normalise ())
+        continue;
+
+      mapspace &ms = *pos;
+
+      if (ms.flags () & P_IS_ALIVE)
+        continue;
+
+      /* However, often
+       * ob doesn't have any move type (when used to place exits)
+       * so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
+       */
+      if (ob->move_type == 0 && ms.move_block != MOVE_ALL)
+        continue;
 
       /* Basically, if we find a wall on a space, we cut down the search size.
        * In this way, we won't return spaces that are on another side of a wall.
@@ -2027,8 +2023,19 @@
        * to only the spaces immediately surrounding the target area, and
        * won't look 2 spaces south of the target space.
        */
-      else if ((flag & P_NO_PASS) && maxfree[i] < stop)
-        stop = maxfree[i];
+      if (ms.move_block == MOVE_ALL && maxfree[i] < stop)
+        {
+          stop = maxfree[i];
+          continue;
+        }
+
+      /* Note it is intentional that we check ob - the movement type of the
+       * head of the object should correspond for the entire object.
+       */
+      if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
+        continue;
+
+      altern [index++] = i;
     }
 
   if (!index)
@@ -2047,7 +2054,7 @@
 find_first_free_spot (const object *ob, maptile *m, int x, int y)
 {
   for (int i = 0; i < SIZEOFFREE; i++)
-    if (!ob_blocked (ob, m, x + freearr_x[i], y + freearr_y[i]))
+    if (!ob->blocked (m, x + freearr_x[i], y + freearr_y[i]))
       return i;
 
   return -1;