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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.96 by root, Sat Dec 30 10:16:10 2006 UTC vs.
Revision 1.107 by pippijn, Sat Jan 6 14:42:29 2007 UTC

 /*
     CrossFire, A Multiplayer game for X-windows
+    Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
     Copyright (C) 2001 Mark Wedel & Crossfire Development Team
     Copyright (C) 1992 Frank Tore Johansen
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
   /* Note sure why the following is the case - either the object has to
    * be animated or have a very low speed.  Is this an attempted monster
    * check?
    */
-  if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && FABS ((ob1)->speed) > MIN_ACTIVE_SPEED)
+  if (!QUERY_FLAG (ob1, FLAG_ANIMATE) && ob1->has_active_speed ())
     return 0;
   switch (ob1->type)
     {
       case SCROLL:
       speed = 0;
     }
   this->speed = speed;
-  if (FABS (speed) > MIN_ACTIVE_SPEED)
+  if (has_active_speed ())
-    {
+    activate ();
-      /* 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;
-    }
   else
-    {
+    deactivate ();
-      /* If not on the active list, nothing needs to be done */
-      if (!active_next && !active_prev && this != active_objects)
-        return;
-      if (!active_prev)
-        {
-          active_objects = active_next;
-          if (active_next)
-            active_next->active_prev = 0;
-        }
-      else
-        {
-          active_prev->active_next = active_next;
-          if (active_next)
-            active_next->active_prev = active_prev;
-        }
-      active_next = 0;
-      active_prev = 0;
-    }
 }
 /*
  * 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 ()
+{
+  /* If already on active list, don't do anything */
+  if (active ())
+    return;
+  if (has_active_speed ())
+    {
+      /* 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;
+    }
+}
+void
-object::activate (bool recursive)
+object::activate_recursive ()
 {
-  // uh, hack
+  activate ();
-  set_speed (speed);
-  if (recursive)
-    for (object *op = inv; op; op = op->above)
+  for (object *op = inv; op; op = op->below)
-      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->below)
+    op->deactivate_recursive ();
-      op->deactivate (1);
+  deactivate ();
+}
+void
+object::set_flag_inv (int flag, int value)
+{
+  for (object *op = inv; op; op = op->below)
+    {
+      op->flag [flag] = value;
+      op->set_flag_inv (flag, value);
+    }
 }
 /*
  * Remove and free all objects in the inventory of the given object.
  * object.c ?
         freed_map->name   = "/internal/freed_objects_map";
         freed_map->width  = 3;
         freed_map->height = 3;
         freed_map->alloc ();
+        freed_map->in_memory = MAP_IN_MEMORY;
       }
     map = freed_map;
     x = 1;
     y = 1;
   else if (map)
     {
       if (type == PLAYER)
         {
           --map->players;
-          map->last_access = runtime;
+          map->touch ();
         }
+      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);
     {
       /* The part may be on a different map. */
       object *more = op->more;
-      /* We really need the caller to normalize coordinates - if
+      /* We really need the caller to normalise coordinates - if
        * we set the map, that doesn't work if the location is within
        * a map and this is straddling an edge.  So only if coordinate
-       * is clear wrong do we normalize it.
+       * is clear wrong do we normalise it.
        */
       if (OUT_OF_REAL_MAP (more->map, more->x, more->y))
         more->map = get_map_from_coord (m, &more->x, &more->y);
       else if (!more->map)
         {
   if (op->type == PLAYER)
     {
       op->contr->do_los = 1;
       ++op->map->players;
-      op->map->last_access = runtime;
+      op->map->touch ();
     }
+  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))
    * 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);
 {
   object *tmp, *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)
+  for (tmp = op->ms ().bot; tmp; tmp = tmp->above)
     if (!strcmp (tmp->arch->name, arch_string))       /* same archetype */
       tmp->destroy ();
   tmp1 = arch_to_object (archetype::find (arch_string));
   /* The objects have to be checked from top to bottom.
    * Hence, we first go to the top:
    */
-  for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp && tmp->above; tmp = tmp->above)
+  for (tmp = op->ms ().bot; tmp && tmp->above; tmp = tmp->above)
     {
       /* Trim the search when we find the first other spell effect
        * this helps performance so that if a space has 50 spell objects,
        * we don't need to check all of them.
        */
  * The first matching object is returned, or NULL if none.
  */
 object *
 present_arch (const archetype *at, maptile *m, int x, int y)
 {
-  if (m == NULL || out_of_map (m, x, y))
+  if (!m || out_of_map (m, x, y))
     {
       LOG (llevError, "Present_arch called outside map.\n");
       return NULL;
     }
-  for (object *tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
+  for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
     if (tmp->arch == at)
       return tmp;
   return NULL;
 }
     {
       LOG (llevError, "Present called outside map.\n");
       return NULL;
     }
-  for (object *tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
+  for (object *tmp = m->at (x, y).bot; tmp; tmp = tmp->above)
     if (tmp->type == type)
       return tmp;
   return NULL;
 }
     }
   else
     item = item->env;
 }
+const char *
+object::flag_desc (char *desc, int len) const
+{
+  char *p = desc;
+  bool first = true;
+  *p = 0;
+  for (int i = 0; i < NUM_FLAGS; i++)
+    {
+      if (len <= 10) // magic constant!
+        {
+          snprintf (p, len, ",...");
+          break;
+        }
+      if (flag [i])
+        {
+          int cnt = snprintf (p, len, "%s%d", first ? "" : ",", i);
+          len -= cnt;
+          p += cnt;
+          first = false;
+        }
+    }
+  return desc;
+}
-// return a suitable string describing an objetc in enough detail to find it
+// return a suitable string describing an object in enough detail to find it
 const char *
 object::debug_desc (char *info) const
 {
+  char flagdesc[512];
-  char info2[256 * 3];
+  char info2[256 * 4];
   char *p = info;
-  p += snprintf (p, 256, "%d=\"%s%s%s\"",
+  p += snprintf (p, 512, "{cnt:%d,uuid:<1,%" PRIx64 ">,name:\"%s%s%s\",flags:[%s],type:%d}",
-                 count,
+                 count, uuid.seq,
                  &name,
-                 title ? " " : "",
+                 title ? "\",title:" : "",
-                 title ? (const char *)title : "");
+                 title ? (const char *)title : "",
+                 flag_desc (flagdesc, 512), type);
   if (env)
     p += snprintf (p, 256, "(in %s)", env->debug_desc (info2));
   if (map)
 }
 const char *
 object::debug_desc () const
 {
-  static char info[256 * 3];
+  static char info[256 * 4];
   return debug_desc (info);
 }

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.96 by root, Sat Dec 30 10:16:10 2006 UTC vs. Revision 1.107 by pippijn, Sat Jan 6 14:42:29 2007 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.96 by root, Sat Dec 30 10:16:10 2006 UTC vs.
Revision 1.107 by pippijn, Sat Jan 6 14:42:29 2007 UTC