--- deliantra/server/common/object.C	2007/08/24 01:23:29	1.185
+++ deliantra/server/common/object.C	2007/09/15 15:58:06	1.190
@@ -917,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;
@@ -1232,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)
@@ -1251,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 ();
 
@@ -2002,14 +1993,30 @@
 int
 find_free_spot (const object *ob, maptile *m, int x, int y, int start, int stop)
 {
-  int index = 0, flag;
   int altern[SIZEOFFREE];
+  int index = 0, flag;
 
   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)
+        {
+          altern [index++] = i;
+          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.
@@ -2019,8 +2026,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)
@@ -2039,7 +2057,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;