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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.97 by elmex, Sat Dec 30 21:07:46 2006 UTC vs.
Revision 1.99 by root, Sun Dec 31 18:10:40 2006 UTC

     }
   this->speed = speed;
   if (has_active_speed ())
-    activate (false);
+    activate ();
   else
-    deactivate (false);
+    deactivate ();
 }
 /*
  * update_object() updates the the map.
  * It takes into account invisible objects (and represent squares covered
       return;
     }
   mapspace &m = op->ms ();
-  if (m.flags_ & P_NEED_UPDATE)
+  if (!(m.flags_ & P_UPTODATE))
     /* nop */;
   else if (action == UP_OBJ_INSERT)
     {
       // this is likely overkill, TODO: revisit (schmorp)
       if ((QUERY_FLAG (op, FLAG_BLOCKSVIEW)  && !(m.flags_ & P_BLOCKSVIEW))
           /* This isn't perfect, but I don't expect a lot of objects to
            * to 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_ = P_NEED_UPDATE;
+        m.flags_ = 0;
     }
     /* if the object is being removed, we can't make intelligent
      * decisions, because remove_ob can't really pass the object
      * that is being removed.
      */
   else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
-    m.flags_ = P_NEED_UPDATE;
+    m.flags_ = 0;
   else if (action == UP_OBJ_FACE)
     /* Nothing to do for that case */ ;
   else
     LOG (llevError, "update_object called with invalid action: %d\n", action);
   if (op->more)
     update_object (op->more, action);
 }
-object::vector object::objects; // not yet used
 object *object::first;
 object::object ()
 {
   SET_FLAG (this, FLAG_REMOVED);
   prev = 0;
   next = 0;
 }
+bool
+object::active () const
+{
+  return active_next || active_prev || this == active_objects;
+}
 void
-object::activate (bool recursive)
+object::activate ()
 {
+  /* If already on active list, don't do anything */
+  if (active ())
+    return;
   if (has_active_speed ())
     {
-      /* If already on active list, don't do anything */
-      if (active_next || active_prev || this == active_objects)
-        return;
       /* process_events() expects us to insert the object at the beginning
        * of the list. */
       active_next = active_objects;
       if (active_next)
         active_next->active_prev = this;
       active_objects = this;
     }
+}
-  if (recursive)
+void
+object::activate_recursive ()
+{
+  activate ();
-    for (object *op = inv; op; op = op->above)
+  for (object *op = inv; op; op = op->above)
-      op->activate (1);
+    op->activate_recursive ();
 }
 /* This function removes object 'op' from the list of active
  * objects.
  * This should only be used for style maps or other such
  * in play chewing up cpu time getting processed.
  * The reverse of this is to call update_ob_speed, which
  * will do the right thing based on the speed of the object.
  */
 void
-object::deactivate (bool recursive)
+object::deactivate ()
 {
   /* If not on the active list, nothing needs to be done */
-  if (!active_next && !active_prev && this != active_objects)
+  if (!active ())
     return;
   if (active_prev == 0)
     {
       active_objects = active_next;
         active_next->active_prev = active_prev;
     }
   active_next = 0;
   active_prev = 0;
+}
-  if (recursive)
+void
+object::deactivate_recursive ()
+{
-    for (object *op = inv; op; op = op->above)
+  for (object *op = inv; op; op = op->above)
+    op->deactivate_recursive ();
-      op->deactivate (1);
+  deactivate ();
 }
 /*
  * Remove and free all objects in the inventory of the given object.
  * object.c ?
         {
           --map->players;
           map->last_access = runtime;
         }
+      map->dirty = true;
       /* link the object above us */
       if (above)
         above->below = below;
       else
         }
       /* 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_ = P_NEED_UPDATE;
+        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);
       op->contr->do_los = 1;
       ++op->map->players;
       op->map->last_access = runtime;
     }
+  op->map->dirty = true;
   /* 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))
     if (object *pl = op->ms ().player ())
    * 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
    * be far away from this change and not affected in any way -
    * this should get redone to only look for players within range,
-   * or just updating the P_NEED_UPDATE for spaces within this area
+   * or just updating the P_UPTODATE for spaces within this area
    * of effect may be sufficient.
    */
   if (op->map->darkness && (op->glow_radius != 0))
     update_all_los (op->map, op->x, op->y);

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.97 by elmex, Sat Dec 30 21:07:46 2006 UTC vs. Revision 1.99 by root, Sun Dec 31 18:10:40 2006 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.97 by elmex, Sat Dec 30 21:07:46 2006 UTC vs.
Revision 1.99 by root, Sun Dec 31 18:10:40 2006 UTC