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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.237 by root, Tue May 6 21:04:37 2008 UTC vs.
Revision 1.255 by root, Sun Aug 31 02:01:41 2008 UTC

       || ob1->speed != ob2->speed
       || ob1->value != ob2->value
       || ob1->name  != ob2->name)
     return 0;
-  /* Do not merge objects if nrof would overflow. First part checks
+  /* Do not merge objects if nrof would overflow, assume nrof
-   * for unsigned overflow (2c), second part checks whether the result
+   * is always 0 .. 2**31-1 */
-   * would fit into a 32 bit signed int, which is often used to hold
+  if (ob1->nrof > 0x7fffffff - ob2->nrof)
-   * nrof values.
-   */
-  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
    * just can't ignore the been applied or identified flags, as they
     SET_FLAG (ob1, FLAG_BEEN_APPLIED);
   if (QUERY_FLAG (ob2, FLAG_IDENTIFIED))
     SET_FLAG (ob2, FLAG_BEEN_APPLIED);
-  if (ob1->arch->name      != ob2->arch->name
+  if (ob1->arch->archname  != ob2->arch->archname
       || ob1->name         != ob2->name
       || ob1->title        != ob2->title
       || ob1->msg          != ob2->msg
       || ob1->weight       != ob2->weight
       || ob1->attacktype   != ob2->attacktype
       || ob1->magic        != ob2->magic
       || ob1->slaying      != ob2->slaying
       || ob1->skill        != ob2->skill
       || ob1->value        != ob2->value
       || ob1->animation_id != ob2->animation_id
+      || (ob1->face != ob2->face && !ob1->animation_id) // face and animation are dependent on each other
       || ob1->client_type  != ob2->client_type
       || ob1->materialname != ob2->materialname
       || ob1->lore         != ob2->lore
       || ob1->subtype      != ob2->subtype
       || ob1->move_type    != ob2->move_type
       || memcmp (&ob1->stats , &ob2->stats , sizeof (ob1->stats)))
     return 0;
   if ((ob1->flag ^ ob2->flag)
       .reset (FLAG_INV_LOCKED)
-      .reset (FLAG_CLIENT_SENT)
       .reset (FLAG_REMOVED)
       .any ())
     return 0;
   /* This is really a spellbook check - we should in general
       else
         {
           // maybe there is a player standing on the same mapspace
           // this will catch the case where "this" is a player
           if (object *pl = ms ().player ())
+            if ((!pl->container && pl->contr->ns && !pl->contr->ns->update_look)
-            if (!pl->container || this == pl->container)
+                || this == pl->container)
               return pl;
         }
     }
   return 0;
  */
 object *
 find_object_name (const char *str)
 {
   shstr_cmp str_ (str);
-  object *op;
+  if (str_)
-  for_all_objects (op)
+    for_all_objects (op)
-    if (op->name == str_)
+      if (op->name == str_)
-      break;
+        return op;
-  return op;
+  return 0;
 }
 /*
  * Sets the owner and sets the skill and exp pointers to owner's current
  * skill and experience objects.
           || (QUERY_FLAG (op, FLAG_DAMNED)   && !(m.flags_ & P_NO_CLERIC))
           || (m.move_on   | op->move_on  ) != m.move_on
           || (m.move_off  | op->move_off ) != m.move_off
           || (m.move_slow | op->move_slow) != m.move_slow
           /* This isn't perfect, but I don't expect a lot of objects to
-           * to have move_allow right now.
+           * have move_allow right now.
            */
           || ((m.move_block | op->move_block) & ~op->move_allow) != m.move_block
           || 1) // the above is not strong enough a test to skip updating. los maybe? TODO (Schmorp)
         m.flags_ = 0;
     }
    * drop on that space.
    */
   if (!drop_to_ground
       || !map
       || map->in_memory != MAP_ACTIVE
-      || map->nodrop
+      || map->no_drop
       || ms ().move_block == MOVE_ALL)
     {
       while (inv)
-        {
-          inv->destroy_inv (false);
-          inv->destroy ();
+        inv->destroy (true);
-        }
     }
   else
     {                       /* Put objects in inventory onto this space */
       while (inv)
         {
 static struct freed_map : maptile
 {
   freed_map ()
   {
-    path   = "<freed objects map>";
+    path     = "<freed objects map>";
-    name   = "/internal/freed_objects_map";
+    name     = "/internal/freed_objects_map";
-    width  = 3;
+    width    = 3;
-    height = 3;
+    height   = 3;
-    nodrop = 1;
+    no_drop  = 1;
+    no_reset = 1;
     alloc ();
     in_memory = MAP_ACTIVE;
   }
       *(below ? &below->above : &ms.bot) = above;
       above = 0;
       below = 0;
+      ms.flags_ = 0;
       if (map->in_memory == MAP_SAVING)
         return;
       int check_walk_off = !flag [FLAG_NO_APPLY];
             }
           last = tmp;
         }
-      /* last == NULL if there are no objects on this space */
-      //TODO: this makes little sense, why only update the topmost object?
-      if (!last)
-        map->at (x, y).flags_ = 0;
-      else
-        update_object (last, UP_OBJ_REMOVE);
       if (flag [FLAG_BLOCKSVIEW] || glow_radius)
         update_all_los (map, x, y);
     }
 }
  * job preparing multi-part monsters.
  */
 object *
 insert_ob_in_map_at (object *op, maptile *m, object *originator, int flag, int x, int y)
 {
+  op->remove ();
   for (object *tmp = op->head_ (); tmp; tmp = tmp->more)
     {
       tmp->x = x + tmp->arch->x;
       tmp->y = y + tmp->arch->y;
     }
  *   just 'op' otherwise
  */
 object *
 insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
 {
+  if (op->is_on_map ())
+    {
+      LOG (llevError, "insert_ob_in_map called for object already on map");
+      abort ();
+    }
+  if (op->env)
+    {
+      LOG (llevError, "insert_ob_in_map called for object in an inventory (proceeding)");
-  op->remove ();
+      op->remove ();
+    }
+  if (op->face && !face_info (op->face))//D TODO: remove soon
+    {//D
+      LOG (llevError | logBacktrace, "op->face out of bounds: %s", op->debug_desc ());//D
+      op->face = 1;//D
+    }//D
   /* 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 (!QUERY_FLAG (op, FLAG_ALIVE))
     CLEAR_FLAG (op, FLAG_NO_STEAL);
   if (flag & INS_BELOW_ORIGINATOR)
     {
-      if (originator->map != op->map || originator->x != op->x || originator->y != op->y || !originator->is_on_map ())
+      if (originator->map != op->map || originator->x != op->x || originator->y != op->y)
         {
           LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
           abort ();
         }
+      if (!originator->is_on_map ())
+        LOG (llevDebug | logBacktrace, "insert_ob_in_map(%s) called with INS_BELOW_ORIGINATOR when originator '%s' not on map",
+             op->debug_desc (), originator->debug_desc ());
       op->above = originator;
       op->below = originator->below;
       originator->below = op;
         }                       /* If objects on this space */
       if (flag & INS_ABOVE_FLOOR_ONLY)
         top = floor;
-      /* Top is the object that our object (op) is going to get inserted above.
+      // insert object above top, or bottom-most if top = 0
-       */
-      /* no top found, insert on top */
       if (!top)
         {
-          op->above = 0;
+          op->below = 0;
-          op->below = ms.top;
+          op->above = ms.bot;
-          ms.top = op;
+          ms.bot = op;
-          *(op->below ? &op->below->above : &ms.bot) = op;
+          *(op->above ? &op->above->below : &ms.top) = op;
         }
       else
-        {                       /* get inserted into the stack above top */
+        {
           op->above = top->above;
           top->above = op;
           op->below = top;
           *(op->above ? &op->above->below : &ms.top) = op;
         }
-    }                           /* else not INS_BELOW_ORIGINATOR */
+    }
   if (op->type == PLAYER)
     {
       op->contr->do_los = 1;
       ++op->map->players;
   if (!nr)
     return true;
   nr = min (nr, nrof);
+  if (nrof > nr)
+    {
-  nrof -= nr;
+      nrof -= nr;
-  if (nrof)
-    {
-      adjust_weight (env, -weight * nr); // carrying == 0
+      adjust_weight (env, -weight * max (1, nr)); // carrying == 0
       if (object *pl = visible_to ())
         esrv_update_item (UPD_NROF, pl, this);
       return true;
     }
   else
     {
-      destroy (1);
+      destroy ();
       return false;
     }
 }
 /*
 {
   char flagdesc[512];
   char info2[256 * 4];
   char *p = info;
-  p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s,flags:[%s],type:%d}",
+  p += snprintf (p, 512, "{cnt:%d,uuid:%s,name:\"%s\"%s%s%s,flags:[%s],type:%d}",
                  count,
                  uuid.c_str (),
                  &name,
-                 title ? "\",title:\"" : "",
+                 title ? ",title:\"" : "",
                  title ? (const char *)title : "",
+                 title ? "\"" : "",
                  flag_desc (flagdesc, 512), type);
   if (!flag[FLAG_REMOVED] && env)
     p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.237 by root, Tue May 6 21:04:37 2008 UTC vs. Revision 1.255 by root, Sun Aug 31 02:01:41 2008 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.237 by root, Tue May 6 21:04:37 2008 UTC vs.
Revision 1.255 by root, Sun Aug 31 02:01:41 2008 UTC