[ViewVC] Diff of: cvs/deliantra/server/common/object.C

Comparing deliantra/server/common/object.C (file contents):
Revision 1.204 by root, Fri Apr 11 17:01:52 2008 UTC vs.
Revision 1.207 by root, Sun Apr 20 23:25:09 2008 UTC

  */
 /* Eneq(@csd.uu.se): Added weight-modifiers in environment of objects.
    sub/add_weight will transcend the environment updating the carrying
    variable. */
 #include <global.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <object.h>
 {
   read_uuid ();
 }
 /* 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;
   /* n-squared behaviour (see get_ob_key_link()), but I'm hoping both
       key_value *has_field;
       /* Look for a field in has with the same key. */
       has_field = get_ob_key_link (has, wants_field->key);
-      if (has_field == NULL)
+      if (!has_field)
-        {
-          /* No field with that name. */
+        return 0; /* No field with that name. */
-          return FALSE;
-        }
       /* Found the matching field. */
       if (has_field->value != wants_field->value)
-        {
-          /* Values don't match, so this half of the comparison is false. */
+        return 0; /* Values don't match, so this half of the comparison is false. */
-          return 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,
    * so we need to run the comparison *twice*. :(
    */
       || ob1->speed != ob2->speed
       || ob1->value != ob2->value
       || 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. First part checks
-  /* Do not merge objects if nrof would overflow. We use 1UL<<31 since that
+   * for unsigned overflow (2c), second part checks wether the result
-   * value could not be stored in a sint32 (which unfortunately sometimes is
+   * would fit into a 32 bit signed int, which is often used to hold
-   * used to store nrof).
+   * 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.
    */
   if (QUERY_FLAG (ob1, FLAG_IDENTIFIED))
       || ob1->move_off     != ob2->move_off
       || ob1->move_slow    != ob2->move_slow
       || ob1->move_slow_penalty != ob2->move_slow_penalty)
     return 0;
-  /* This is really a spellbook check - really, we should
+  /* This is really a spellbook check - we should in general
-   * check all objects in the inventory.
+   * not merge objects with real inventories, as splitting them
+   * is hard.
    */
   if (ob1->inv || ob2->inv)
     {
       if (!(ob1->inv && ob2->inv))
         return 0; /* inventories differ in length */
       if (ob1->inv->below || ob2->inv->below)
         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.
        */
     }
         if (ob1->level != ob2->level)
           return 0;
         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))
         return 0;
     }
   /* Everything passes, must be OK. */
   return 1;
 }
+static sint32
+weight_adjust (object *op, sint32 weight)
+{
+  return op->type == CONTAINER
+         ? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
+         : weight;
+}
 /*
+ * add_weight(object, weight) adds the specified weight to an object,
+ * and also updates how much the environment(s) is/are carrying.
+ */
+static void
+add_weight (object *op, sint32 weight)
+{
+  while (op)
+    {
+      weight = weight_adjust (op, weight);
+      op->carrying += weight;
+      op = op->env;
+    }
+}
+/*
+ * sub_weight() recursively (outwards) subtracts a number from the
+ * weight of an object (and what is carried by it's environment(s)).
+ */
+static void
+sub_weight (object *op, long weight)
+{
+  add_weight (op, -weight);
+}
+/*
- * sum_weight() is a recursive function which calculates the weight
+ * this is a recursive function which calculates the weight
- * an object is carrying.  It goes through in figures out how much
+ * an object is carrying. It goes through op and figures out how much
  * containers are carrying, and sums it up.
  */
-long
+void
-sum_weight (object *op)
+object::update_weight ()
 {
-  long sum;
+  sint32 sum = 0;
-  object *inv;
-  for (sum = 0, inv = op->inv; inv; inv = inv->below)
+  for (object *op = inv; op; op = op->below)
     {
-      if (inv->inv)
+      if (op->inv)
-        sum_weight (inv);
+        op->update_weight ();
-      sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1);
+      sum += op->total_weight ();
     }
-  if (op->type == CONTAINER && op->stats.Str)
+  carrying = weight_adjust (this, sum);
-    sum = (sum * (100 - op->stats.Str)) / 100;
-  if (op->carrying != sum)
-    op->carrying = sum;
-  return sum;
-}
-/**
- * Return the outermost environment object for a given object.
- */
-object *
-object_get_env_recursive (object *op)
-{
-  while (op->env != NULL)
-    op = op->env;
-  return op;
 }
 /*
  * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
  *      Some error messages.
    * if some form of movement is allowed, let objects
    * drop on that space.
    */
   if (!drop_to_ground
       || !map
-      || map->in_memory != MAP_IN_MEMORY
+      || map->in_memory != MAP_ACTIVE
       || map->nodrop
       || ms ().move_block == MOVE_ALL)
     {
       while (inv)
         {
         freed_map->width  = 3;
         freed_map->height = 3;
         freed_map->nodrop = 1;
         freed_map->alloc ();
-        freed_map->in_memory = MAP_IN_MEMORY;
+        freed_map->in_memory = MAP_ACTIVE;
       }
     map = freed_map;
     x = 1;
     y = 1;
       play_sound (sound_destroy);
     else if (flag [FLAG_MONSTER])
       play_sound (sound_find ("monster_destroy")); // quick hack, too lazy to create a generic mechanism
   attachable::destroy ();
-}
-/*
- * sub_weight() recursively (outwards) subtracts a number from the
- * weight of an object (and what is carried by it's environment(s)).
- */
-void
-sub_weight (object *op, signed long weight)
-{
-  while (op != NULL)
-    {
-      if (op->type == CONTAINER)
-        weight = (signed long) (weight * (100 - op->stats.Str) / 100);
-      op->carrying -= weight;
-      op = op->env;
-    }
 }
 /* op->remove ():
  *   This function removes the object op from the linked list of objects
  *   which it is currently tied to.  When this function is done, the
 }
 object *
 object::insert_at (object *where, object *originator, int flags)
 {
+  if (where->env)
+    return where->env->insert (this);
+  else
-  return where->map->insert (this, where->x, where->y, originator, flags);
+    return where->map->insert (this, where->x, where->y, originator, flags);
 }
 /*
  * get_split_ob(ob,nr) splits up ob into two parts.  The part which
  * is returned contains nr objects, and the remaining parts contains
     orig_ob->destroy (1);
   else if (!is_removed)
     {
       if (orig_ob->env != NULL)
         sub_weight (orig_ob->env, orig_ob->weight * nr);
-      if (orig_ob->env == NULL && orig_ob->map->in_memory != MAP_IN_MEMORY)
+      if (orig_ob->env == NULL && orig_ob->map->in_memory != MAP_ACTIVE)
         {
           strcpy (errmsg, "Tried to split object whose map is not in memory.");
           LOG (llevDebug, "Error, Tried to split object whose map is not in memory.\n");
           return NULL;
         }
     return op;
   else
     {
       op->destroy ();
       return 0;
-    }
-}
-/*
- * add_weight(object, weight) adds the specified weight to an object,
- * and also updates how much the environment(s) is/are carrying.
- */
-void
-add_weight (object *op, signed long weight)
-{
-  while (op != NULL)
-    {
-      if (op->type == CONTAINER)
-        weight = (signed long) (weight * (100 - op->stats.Str) / 100);
-      op->carrying += weight;
-      op = op->env;
     }
 }
 object *
 insert_ob_in_ob (object *op, object *where)

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/common/object.C (file contents): Revision 1.204 by root, Fri Apr 11 17:01:52 2008 UTC vs. Revision 1.207 by root, Sun Apr 20 23:25:09 2008 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.204 by root, Fri Apr 11 17:01:52 2008 UTC vs.
Revision 1.207 by root, Sun Apr 20 23:25:09 2008 UTC