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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.343 by root, Sat Apr 23 04:56:46 2011 UTC vs.
Revision 1.349 by root, Sun May 8 11:44:43 2011 UTC

 /* Returns TRUE if every key_values in wants has a partner with the same value in has. */
 static bool
 compare_ob_value_lists_one (const object *wants, const object *has)
 {
-  /* n-squared behaviour (see kv_get), but I'm hoping both
+  /* n-squared behaviour (see kv.get), but I'm hoping both
    * objects with lists are rare, and lists stay short. If not, use a
    * different structure or at least keep the lists sorted...
    */
   /* For each field in wants, */
-  for (key_value *kv = wants->key_values; kv; kv = kv->next)
+  for (key_value *kv = wants->kv.first; kv; kv = kv->next)
-    if (has->kv_get (kv->key) != kv->value)
+    if (has->kv.get (kv->key) != kv->value)
       return false;
   /* If we get here, every field in wants has a matching field in has. */
   return true;
 }
         if (ob1->level != ob2->level)
           return 0;
         break;
     }
-  if (ob1->key_values || ob2->key_values)
+  if (!ob1->kv.empty () || !ob2->kv.empty ())
     {
       /* At least one of these has key_values. */
-      if ((!ob1->key_values) != (!ob2->key_values))
+      if (ob1->kv.empty () != ob2->kv.empty ())
         return 0; /* One has fields, but the other one doesn't. */
       if (!compare_ob_value_lists (ob1, ob2))
         return 0;
     }
     }
   this->owner = owner;
 }
-/* Zero the key_values on op, decrementing the shared-string
- * refcounts and freeing the links.
- */
-static void
-free_key_values (object *op)
-{
-  for (key_value *i = op->key_values; i; )
-    {
-      key_value *next = i->next;
-      delete i;
-      i = next;
-    }
-  op->key_values = 0;
-}
 /*
  * copy_to first frees everything allocated by the dst object,
  * and then copies the contents of itself into the second
  * object, allocating what needs to be allocated.  Basically, any
  * data that is malloc'd needs to be re-malloc/copied.  Otherwise,
 void
 object::copy_to (object *dst)
 {
   dst->remove ();
   *(object_copy *)dst = *this;
+  // maybe move to object_copy?
+  dst->kv = kv;
   dst->flag [FLAG_REMOVED] = true;
-  /* Copy over key_values, if any. */
-  if (key_values)
-    {
-      key_value *tail = 0;
-      dst->key_values = 0;
-      for (key_value *i = key_values; i; i = i->next)
-        {
-          key_value *new_link = new key_value;
-          new_link->next  = 0;
-          new_link->key   = i->key;
-          new_link->value = i->value;
-          /* Try and be clever here, too. */
-          if (!dst->key_values)
-            {
-              dst->key_values = new_link;
-              tail = new_link;
-            }
-          else
-            {
-              tail->next = new_link;
-              tail = new_link;
-            }
-        }
-    }
   dst->activate ();
 }
 void
 object::instantiate ()
     }
   mapspace &m = op->ms ();
   if (!(m.flags_ & P_UPTODATE))
-    /* nop */;
+    m.update_up (); // nothing to do except copy up
   else if (action == UP_OBJ_INSERT)
     {
 #if 0
       // this is likely overkill, TODO: revisit (schmorp)
       if ((op->flag [FLAG_BLOCKSVIEW]  && !(m.flags_ & P_BLOCKSVIEW))
      * that is being removed.
      */
   else if (action == UP_OBJ_CHANGE || action == UP_OBJ_REMOVE)
     m.invalidate ();
   else if (action == UP_OBJ_FACE)
-    /* Nothing to do for that case */ ;
+    m.update_up (); // nothing to do for that case, except copy up
   else
     LOG (llevError, "update_object called with invalid action: %d\n", action);
   if (op->more)
     update_object (op->more, action);
 object::~object ()
 {
   unlink ();
-  free_key_values (this);
+  kv.clear ();
 }
 void object::link ()
 {
   assert (!index);//D
    * if some form of movement is allowed, let objects
    * drop on that space.
    */
   if (!drop_to_ground
       || !map
-      || map->in_memory != MAP_ACTIVE
+      || !map->linkable ()
       || map->no_drop
       || ms ().move_block == MOVE_ALL)
     {
       while (inv)
         inv->destroy ();
     path     = "<freed objects map>";
     name     = "/internal/freed_objects_map";
     no_drop  = 1;
     no_reset = 1;
-    in_memory = MAP_ACTIVE;
+    state = MAP_ACTIVE;
   }
   ~freed_map ()
   {
     destroy ();
       above = 0;
       below = 0;
       ms.invalidate ();
-      if (map->in_memory == MAP_SAVING)
-        return;
       int check_walk_off = !flag [FLAG_NO_APPLY];
       if (object *pl = ms.player ())
         {
 {
   op->remove ();
   if (m == &freed_map)//D TODO: remove soon
     {//D
-      LOG (llevError | logBacktrace, "tries to insret object on freed objects map: %s", op->debug_desc ());//D
+      LOG (llevError | logBacktrace, "tries to insert object on freed objects map: %s", op->debug_desc ());//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
   return                        /*who->flag [FLAG_WIZ]|| */
     (item->weight > 0 && !item->flag [FLAG_NO_PICK] &&
      !item->flag [FLAG_ALIVE] && !item->invisible && (who->is_player () || item->weight < who->weight / 3));
 }
+//-GPL
 /*
  * create clone from object to another
  */
 object *
 object::deep_clone ()
       return tmp;
   return 0;
 }
+/* Zero the key_values on op, decrementing the shared-string
+ * refcounts and freeing the links.
+ */
+void
+key_values::clear ()
+{
+  for (key_value *kvp = first; kvp; )
+    {
+      key_value *next = kvp->next;
+      delete kvp;
+      kvp = next;
+    }
+  first = 0;
+}
 shstr_tmp
-object::kv_get (shstr_tmp key) const
+key_values::get (shstr_tmp key) const
 {
-  for (key_value *kv = key_values; kv; kv = kv->next)
+  for (key_value *kv = first; kv; kv = kv->next)
     if (kv->key == key)
       return kv->value;
   return shstr ();
 }
 void
+key_values::add (shstr_tmp key, shstr_tmp value)
+{
+  key_value *kv = new key_value;
+  kv->next  = first;
+  kv->key   = key;
+  kv->value = value;
+  first = kv;
+}
+void
-object::kv_set (shstr_tmp key, shstr_tmp value)
+key_values::set (shstr_tmp key, shstr_tmp value)
 {
-  for (key_value *kv = key_values; kv; kv = kv->next)
+  for (key_value *kv = first; kv; kv = kv->next)
     if (kv->key == key)
       {
         kv->value = value;
         return;
       }
-  key_value *kv = new key_value;
+  add (key, value);
-  kv->next  = key_values;
-  kv->key   = key;
-  kv->value = value;
-  key_values = kv;
 }
 void
-object::kv_del (shstr_tmp key)
+key_values::del (shstr_tmp key)
 {
-  for (key_value **kvp = &key_values; *kvp; kvp = &(*kvp)->next)
+  for (key_value **kvp = &first; *kvp; kvp = &(*kvp)->next)
     if ((*kvp)->key == key)
       {
         key_value *kv = *kvp;
         *kvp = (*kvp)->next;
         delete kv;
         return;
       }
+}
+void
+key_values::reverse ()
+{
+  key_value *prev = 0;
+  key_value *head = first;
+  while (head)
+    {
+      key_value *node = head;
+      head = head->next;
+      node->next = prev;
+      prev = node;
+    }
+  first = prev;
+}
+key_values &
+key_values::operator =(const key_values &kv)
+{
+  clear ();
+  for (key_value *kvp = kv.first; kvp; kvp = kvp->next)
+    add (kvp->key, kvp->value);
+  reverse ();
 }
 object::depth_iterator::depth_iterator (object *container)
 : iterator_base (container)
 {
 object::region () const
 {
   return map ? map->region (x, y)
              : region::default_region ();
 }
+//+GPL
 void
 object::open_container (object *new_container)
 {
   if (container == new_container)
     }
 //  else if (!old_container->env && contr && contr->ns)
 //    contr->ns->floorbox_reset ();
 }
+//-GPL
+// prefetch some flat area around the player
+static void
+prefetch_surrounding_area (object *op, maptile *map, int range)
+{
+  for (maprect *rect = map->split_to_tiles (mapwalk_buf,
+                          op->x - range    , op->y - range    ,
+                          op->x + range + 1, op->y + range + 1);
+       rect->m;
+       ++rect)
+    {
+      rect->m->touch ();
+      rect->m->activate ();
+    }
+}
+// prefetch a generous area around the player, also up and down
+void
+object::prefetch_surrounding_maps ()
+{
+  prefetch_surrounding_area (this, map, 40);
+  if (maptile *m = map->tile_available (TILE_DOWN))
+    prefetch_surrounding_area (this, m, 20);
+  if (maptile *m = map->tile_available (TILE_UP))
+    prefetch_surrounding_area (this, m, 20);
+}
+//+GPL
 object *
 object::force_find (shstr_tmp name)
 {
   /* cycle through his inventory to look for the MARK we want to
    * place
       return splay (tmp);
   return 0;
 }
-//-GPL
 void
 object::force_set_timer (int duration)
 {
   this->duration   = 1;
   this->speed_left = -1.f;
 object::force_add (shstr_tmp name, int duration)
 {
   if (object *force = force_find (name))
     force->destroy ();
-  object *force = get_archetype (FORCE_NAME);
+  object *force = archetype::get (FORCE_NAME);
   force->slaying = name;
   force->force_set_timer (duration);
   force->flag [FLAG_APPLIED] = true;

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.343 by root, Sat Apr 23 04:56:46 2011 UTC vs. Revision 1.349 by root, Sun May 8 11:44:43 2011 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.343 by root, Sat Apr 23 04:56:46 2011 UTC vs.
Revision 1.349 by root, Sun May 8 11:44:43 2011 UTC