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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.24 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.25 by root, Mon Sep 11 01:16:20 2006 UTC

 /*
  * static char *rcsid_object_c =
- *   "$Id: object.C,v 1.24 2006/09/10 16:00:23 root Exp $";
+ *   "$Id: object.C,v 1.25 2006/09/11 01:16:20 root Exp $";
  */
 /*
     CrossFire, A Multiplayer game for X-windows
   op->owner = owner;
   op->ownercount = owner->count;
   owner->refcount++;
 }
 /* Set the owner to clone's current owner and set the skill and experience
  * objects to clone's objects (typically those objects that where the owner's
  * current skill and experience objects at the time when clone's owner was
       if (clone->type == PLAYER)
         owner = clone;
       else
         return;
     }
   set_owner (op, owner);
 }
 /* Zero the key_values on op, decrementing the shared-string
  * refcounts and freeing the links.
  */
 void object::clear ()
 {
   attachable_base::clear ();
   free_key_values (this);
+  clear_owner (this);
   name = 0;
   name_pl = 0;
   title = 0;
   race = 0;
   if (op->more != NULL)
     update_object (op->more, action);
 }
-static
+static unordered_vector<object *> mortals;
-std::vector < object *>
+static std::vector<object *> freed;
-  mortals;
 void object::free_mortals ()
 {
-  for (std::vector < object *>::iterator i = mortals.begin (); i != mortals.end (); ++i)
+  for (unordered_vector<object *>::iterator i = mortals.begin (); i != mortals.end (); )
-    delete *
+    if (!(*i)->refcount)
+      {
+        freed.push_back (*i);
+        mortals.erase (i);
+      }
+    else
-      i;
+      ++i;
-  mortals.clear ();
 }
 object::object ()
 {
   SET_FLAG (this, FLAG_REMOVED);
 {
   count = 0;
   /* Remove this object from the list of used objects */
   if (prev)
+    {
-    prev->next = next;
+      prev->next = next;
+      prev = 0;
+    }
   if (next)
+    {
-    next->prev = prev;
+      next->prev = prev;
+      next = 0;
+    }
   if (this == objects)
     objects = next;
 }
 object *object::create ()
 {
-  object *
+  object *op;
+  if (freed.empty ())
     op = new object;
+  else
+    {
+      // highly annoying, but the only way to get it stable right now
+      op = freed.back (); freed.pop_back ();
+      op->~object ();
+      new ((void *)op) object;
+    }
   op->link ();
   return op;
 }
               op = tmp;
             }
         }
     }
+  clear_owner (this);
   /* Remove object from the active list */
   speed = 0;
   update_ob_speed (this);
  */
 object *
 insert_ob_in_map (object *op, mapstruct *m, object *originator, int flag)
 {
-  object *
+  object *tmp, *top, *floor = NULL;
-  tmp, *
+  sint16 x, y;
-  top, *
-    floor = NULL;
-  sint16
-    x,
-    y;
   if (QUERY_FLAG (op, FLAG_FREED))
     {
       LOG (llevError, "Trying to insert freed object!\n");
       return NULL;
     }
   if (m == NULL)
     {
       dump_object (op);
       LOG (llevError, "Trying to insert in null-map!\n%s\n", errmsg);
       return op;
     }
   if (out_of_map (m, op->x, op->y))
     {
       dump_object (op);
       LOG (llevError, "Trying to insert object outside the map.\n%s\n", errmsg);
 #ifdef MANY_CORES
        */
       abort ();
 #endif
       return op;
     }
   if (!QUERY_FLAG (op, FLAG_REMOVED))
     {
       dump_object (op);
       LOG (llevError, "Trying to insert (map) inserted object.\n%s\n", errmsg);
       return op;
     }
   if (op->more != NULL)
     {
       /* The part may be on a different map. */
       object *
           if (!op->head)
             LOG (llevError, "BUG: insert_ob_in_map(): inserting op->more killed op\n");
           return NULL;
         }
     }
   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
   y = op->y;
   /* this has to be done after we translate the coordinates.
    */
   if (op->nrof && !(flag & INS_NO_MERGE))
-    {
-      for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)
+    for (tmp = GET_MAP_OB (op->map, x, y); tmp != NULL; tmp = tmp->above)
-        if (CAN_MERGE (op, tmp))
+      if (CAN_MERGE (op, tmp))
-          {
+        {
-            op->nrof += tmp->nrof;
+          op->nrof += tmp->nrof;
-            remove_ob (tmp);
+          remove_ob (tmp);
-            free_object (tmp);
+          free_object (tmp);
-          }
+        }
-    }
   CLEAR_FLAG (op, FLAG_APPLIED);        /* hack for fixing F_APPLIED in items of dead people */
   CLEAR_FLAG (op, FLAG_INV_LOCKED);
   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)
         {
           LOG (llevError, "insert_ob_in_map called with INS_BELOW_ORIGINATOR when originator not on same space!\n");
           abort ();
         }
       op->above = originator;
       op->below = originator->below;
       if (op->below)
         op->below->above = op;
       else
         SET_MAP_OB (op->map, op->x, op->y, op);
       /* since *below* originator, no need to update top */
       originator->below = op;
     }
   else
     {
       /* If there are other objects, then */
       if ((!(flag & INS_MAP_LOAD)) && ((top = GET_MAP_OB (op->map, op->x, op->y)) != NULL))
         {
-          object *
-            last = NULL;
+          object *last = NULL;
           /*
            * If there are multiple objects on this space, we do some trickier handling.
            * We've already dealt with merging if appropriate.
            * Generally, we want to put the new object on top. But if
                */
               if (last && last->below && last != floor)
                 top = last->below;
             }
         }                       /* If objects on this space */
       if (flag & INS_MAP_LOAD)
         top = GET_MAP_TOP (op->map, op->x, op->y);
       if (flag & INS_ABOVE_FLOOR_ONLY)
         top = floor;
       /* Top is the object that our object (op) is going to get inserted above.
        */
       /* First object on this space */
       if (!top)
         {
           op->above = GET_MAP_OB (op->map, op->x, op->y);
           if (op->above)
             op->above->below = op;
           op->below = NULL;
           SET_MAP_OB (op->map, op->x, op->y, op);
         }
       else
         {                       /* get inserted into the stack above top */
           op->above = top->above;
           if (op->above)
             op->above->below = op;
           op->below = top;
           top->above = op;
         }
       if (op->above == NULL)
         SET_MAP_TOP (op->map, op->x, op->y, op);
     }                           /* else not INS_BELOW_ORIGINATOR */
   if (op->type == PLAYER)
   /* If we have a floor, we know the player, if any, will be above
    * it, so save a few ticks and start from there.
    */
   if (!(flag & INS_MAP_LOAD))
     for (tmp = floor ? floor : GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
-      {
-        if (tmp->type == PLAYER)
+      if (tmp->type == PLAYER)
-          tmp->contr->socket.update_look = 1;
+        tmp->contr->socket.update_look = 1;
-      }
   /* If this object glows, it may affect lighting conditions that are
    * visible to others on this map.  But update_all_los is really
    * an inefficient way to do this, as it means los for all players
    * on the map will get recalculated.  The players could very well
    * blocked() and wall() work properly), and these flags are updated by
    * update_object().
    */
   /* if this is not the head or flag has been passed, don't check walk on status */
   if (!(flag & INS_NO_WALK_ON) && !op->head)
     {
       if (check_move_on (op, originator))
         return NULL;
        */
       for (tmp = op->more; tmp != NULL; tmp = tmp->more)
         if (check_move_on (tmp, originator))
           return NULL;
     }
   return op;
 }
 /* this function inserts an object in the map, but if it
  *  finds an object of its own type, it'll remove that one first.
  *  op is the object to insert it under:  supplies x and the map.
  */
 void
 replace_insert_ob_in_map (const char *arch_string, object *op)
 {
-  object *
+  object *tmp;
-    tmp;
-  object *
+  object *tmp1;
-    tmp1;
   /* first search for itself and remove any old instances */
   for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
     {
           free_object (tmp);
         }
     }
   tmp1 = arch_to_object (find_archetype (arch_string));
   tmp1->x = op->x;
   tmp1->y = op->y;
   insert_ob_in_map (tmp1, op->map, op, 0);
 }

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.24 by root, Sun Sep 10 16:00:23 2006 UTC vs. Revision 1.25 by root, Mon Sep 11 01:16:20 2006 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.24 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.25 by root, Mon Sep 11 01:16:20 2006 UTC