--- deliantra/server/common/object.C	2008/04/11 17:01:52	1.204
+++ deliantra/server/common/object.C	2008/04/13 01:34:08	1.205
@@ -142,7 +142,7 @@
 }
 
 /* Returns TRUE if every key_values in wants has a partner with the same value in has. */
-static int
+static bool
 compare_ob_value_lists_one (const object *wants, const object *has)
 {
   key_value *wants_field;
@@ -160,28 +160,22 @@
       /* Look for a field in has with the same key. */
       has_field = get_ob_key_link (has, wants_field->key);
 
-      if (has_field == NULL)
-        {
-          /* No field with that name. */
-          return FALSE;
-        }
+      if (!has_field)
+        return 0; /* No field with that name. */
 
       /* Found the matching field. */
       if (has_field->value != wants_field->value)
-        {
-          /* Values don't match, so this half of the comparison is false. */
-          return FALSE;
-        }
+        return 0; /* Values don't match, so this half of the comparison is false. */
 
       /* If we get here, we found a match. Now for the next field in wants. */
     }
 
   /* If we get here, every field in wants has a matching field in has. */
-  return TRUE;
+  return 1;
 }
 
 /* Returns TRUE if ob1 has the same key_values as ob2. */
-static int
+static bool
 compare_ob_value_lists (const object *ob1, const object *ob2)
 {
   /* However, there may be fields in has which aren't partnered in wants,
@@ -212,16 +206,16 @@
       || ob1->name  != ob2->name)
     return 0;
 
-  //TODO: this ain't working well, use nicer and correct overflow check
-  /* Do not merge objects if nrof would overflow. We use 1UL<<31 since that
-   * value could not be stored in a sint32 (which unfortunately sometimes is
-   * used to store nrof).
+  /* Do not merge objects if nrof would overflow. First part checks
+   * for unsigned overflow (2c), second part checks wether the result
+   * would fit into a 32 bit signed int, which is often used to hold
+   * nrof values.
    */
-  if (ob1->nrof + ob2->nrof >= 1UL << 31)
+  if (~ob1->nrof < ob2->nrof || ob1->nrof + ob2->nrof > (1UL << 31))
     return 0;
 
   /* If the objects have been identified, set the BEEN_APPLIED flag.
-   * This is to the comparison of the flags below will be OK.  We
+   * This is to the comparison of the flags below will be OK. We
    * just can't ignore the been applied or identified flags, as they
    * are not equal - just if it has been identified, the been_applied
    * flags lose any meaning.
@@ -259,8 +253,9 @@
       || ob1->move_slow_penalty != ob2->move_slow_penalty)
     return 0;
 
-  /* This is really a spellbook check - really, we should
-   * check all objects in the inventory.
+  /* This is really a spellbook check - we should in general
+   * not merge objects with real inventories, as splitting them
+   * is hard.
    */
   if (ob1->inv || ob2->inv)
     {
@@ -271,7 +266,7 @@
         return 0; /* more than one object in inv */
 
       if (!object::can_merge (ob1->inv, ob2->inv))
-        return 0; /* inventory objexts differ */
+        return 0; /* inventory objects differ */
 
       /* inventory ok - still need to check rest of this object to see
        * if it is valid.
@@ -300,10 +295,10 @@
         break;
     }
 
-  if (ob1->key_values != NULL || ob2->key_values != NULL)
+  if (ob1->key_values || ob2->key_values)
     {
       /* At least one of these has key_values. */
-      if ((ob1->key_values == NULL) != (ob2->key_values == NULL))
+      if ((!ob1->key_values) != (!ob2->key_values))
         /* One has fields, but the other one doesn't. */
         return 0;
       else if (!compare_ob_value_lists (ob1, ob2))
@@ -1486,7 +1481,10 @@
 object *
 object::insert_at (object *where, object *originator, int flags)
 {
-  return where->map->insert (this, where->x, where->y, originator, flags);
+  if (where->env)
+    return where->env->insert (this);
+  else
+    return where->map->insert (this, where->x, where->y, originator, flags);
 }
 
 /*