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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.330 by root, Sun Apr 18 14:01:33 2010 UTC vs.
Revision 1.351 by elmex, Fri Jun 3 08:36:45 2011 UTC

 /*
  * This file is part of Deliantra, the Roguelike Realtime MMORPG.
  *
- * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
+ * Copyright (©) 2005,2006,2007,2008,2009,2010,2011 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
  * Copyright (©) 2001 Mark Wedel & Crossfire Development Team
  * Copyright (©) 1992 Frank Tore Johansen
  *
  * Deliantra is free software: you can redistribute it and/or modify it under
  * the terms of the Affero GNU General Public License as published by the
    9, 10, 13, 14, 17, 18, 21, 22,
   25, 26, 27, 30, 31, 32, 33, 36, 37, 39, 39, 42, 43, 44, 45, 48,
   49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49, 49
 };
+const char *wall_suffix[16] = {
+  "0",
+  "1_3",
+  "1_4",
+  "2_1_2",
+  "1_2",
+  "2_2_4",
+  "2_2_1",
+  "3_1",
+  "1_1",
+  "2_2_3",
+  "2_2_2",
+  "3_3",
+  "2_1_1",
+  "3_4",
+  "3_2",
+  "4"
+};
 static void
 write_uuid (uval64 skip, bool sync)
 {
   CALL_BEGIN (2);
   CALL_ARG_SV (newSVval64 (skip));
 /* 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;
 }
  */
 bool object::can_merge_slow (object *ob1, object *ob2)
 {
   /* A couple quick sanity checks */
   if (ob1 == ob2
-      || ob1->type  != ob2->type
+      || ob1->type        != ob2->type
-      || ob1->value != ob2->value
+      || ob1->value       != ob2->value
-      || ob1->name  != ob2->name
+      || ob1->name        != ob2->name
+      || ob1->custom_name != ob2->custom_name
       || fabs (ob1->speed - ob2->speed) >= MIN_ACTIVE_SPEED)
     return 0;
   /* Do not merge objects if nrof would overflow, assume nrof
    * is always 0 .. 2**31-1 */
         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;
     }
   return 0;
 }
 // adjust weight per container type ("of holding")
-static sint32
+static uint32
-weight_adjust_for (object *op, sint32 weight)
+weight_adjust_for (object *op, uint32 weight)
 {
   return op->type == CONTAINER
-         ? lerp (weight, 0, 100, 0, 100 - op->stats.Str)
+         ? weight - weight * op->stats.Str / 100
          : weight;
 }
 /*
- * adjust_weight(object, weight) adds the specified weight to an object,
+ * subtracts, then adds, the specified weight to an object,
  * and also updates how much the environment(s) is/are carrying.
  */
 static void
-adjust_weight (object *op, sint32 weight)
+adjust_weight (object *op, sint32 sub, sint32 add)
 {
   while (op)
     {
-      // adjust by actual difference to account for rounding errors
+      sint32 ocarrying = op->carrying;
-      // i.e. (w2 - w1) / f != w2 / f - w1 / f and the latter is correct
-      weight = weight_adjust_for (op, op->carrying)
-             - weight_adjust_for (op, op->carrying - weight);
-      if (!weight)
+      op->carrying -= weight_adjust_for (op, sub);
-        return;
+      op->carrying += weight_adjust_for (op, add);
-      op->carrying += weight;
       if (object *pl = op->visible_to ())
         if (pl != op) // player is handled lazily
           esrv_update_item (UPD_WEIGHT, pl, op);
+      sub = ocarrying;
+      add = op->carrying;
       op = op->env;
     }
 }
 /*
 {
   sint32 sum = 0;
   for (object *op = inv; op; op = op->below)
     {
-      if (op->inv)
-        op->update_weight ();
+      op->update_weight ();
-      sum += op->total_weight ();
+      sum += weight_adjust_for (this, op->total_weight ());
     }
-  sum = weight_adjust_for (this, sum);
   if (sum != carrying)
     {
-      if (carrying != sum)//D
+      if (carrying != sum && carrying)//D
-        LOG (llevDebug, "updating weight got %ld, expected %ld (%s)\n",
+        LOG (llevDebug, "updating carrying got %ld, expected %ld (%s)\n",
              (long long)sum, (long long)carrying, debug_desc ());
       carrying = sum;
       if (object *pl = visible_to ())
       LOG (llevError | logBacktrace, "tried to set owner of %s to %s\n", debug_desc (), owner->debug_desc ());
       return;
     }
   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
 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 ()
 {
   if (!uuid.seq) // HACK
     uuid = UUID::gen ();
-  // TODO: unclean state changes, should nt be done in copy_to AND instantiate
+  // TODO: unclean state changes, should not be done in copy_to AND instantiate
   if (flag [FLAG_RANDOM_SPEED] && speed)
     speed_left = - speed - rndm (); // TODO animation
   else
     speed_left = -1.;
     }
   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 ();
   freelist = li;
   ++free_count;
 }
-static struct freed_map : maptile
-{
-  freed_map ()
-  : maptile (3, 3)
-  {
-    path     = "<freed objects map>";
-    name     = "/internal/freed_objects_map";
-    no_drop  = 1;
-    no_reset = 1;
-    in_memory = MAP_ACTIVE;
-  }
-  ~freed_map ()
-  {
-    destroy ();
-  }
-} freed_map; // freed objects are moved here to avoid crashes
 void
 object::do_destroy ()
 {
   if (flag [FLAG_IS_LINKED])
     remove_link ();
       flag [FLAG_REMOVED] = false; // hack around the issue of visible_to checking flag_removed
       if (object *pl = visible_to ())
         esrv_del_item (pl->contr, count);
       flag [FLAG_REMOVED] = true; // hack around the issue of visible_to checking flag_removed
-      adjust_weight (env, -total_weight ());
+      adjust_weight (env, total_weight (), 0);
       object *pl = in_player ();
       /* we set up values so that it could be inserted into
        * the map, but we don't actually do that - it is up
       if (pl && pl->is_player ())
         {
           if (expect_false (pl->contr->combat_ob == this))
             {
-              pl->apply (pl->contr->combat_ob, AP_UNAPPLY);
+              pl->apply (pl->contr->combat_ob, AP_UNAPPLY | AP_IGNORE_CURSE);
               pl->contr->combat_ob = 0;
               if (pl->contr->ranged_ob) pl->apply (pl->contr->ranged_ob);
             }
           if (expect_false (pl->contr->ranged_ob == this))
             {
-              pl->apply (pl->contr->ranged_ob, AP_UNAPPLY);
+              pl->apply (pl->contr->ranged_ob, AP_UNAPPLY | AP_IGNORE_CURSE);
               pl->contr->ranged_ob = 0;
               if (pl->contr->combat_ob) pl->apply (pl->contr->combat_ob);
             }
           pl->contr->queue_stats_update ();
       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
    */
   /* if this is not the head or flag has been passed, don't check walk on status */
   if (!(flag & INS_NO_WALK_ON) && op->is_head ())
     {
-      if (check_move_on (op, originator))
+      if (check_move_on (op, originator, flag))
         return 0;
-      /* If we are a multi part object, lets work our way through the check
+      /* If we are a multi part object, let's work our way through the check
        * walk on's.
        */
       for (object *tmp = op->more; tmp; tmp = tmp->more)
-        if (check_move_on (tmp, originator))
+        if (check_move_on (tmp, originator, flag))
           return 0;
     }
   return op;
 }
   nr = min (nr, nrof);
   if (nrof > nr)
     {
+      sint64 oweight = total_weight ();
       nrof -= nr;
-      adjust_weight (env, -weight * max (1, nr)); // carrying == 0
       if (object *pl = visible_to ())
         esrv_update_item (UPD_NROF, pl, this);
+      adjust_weight (env, oweight, total_weight ());
       return true;
     }
   else
     {
   if (op->nrof)
     for (object *tmp = inv; tmp; tmp = tmp->below)
       if (object::can_merge (tmp, op))
         {
           /* return the original object and remove inserted object
-             (client needs the original object) */
+             (client prefers the original object) */
+          // carring must be 0 for mergable objects
+          sint64 oweight = tmp->weight * tmp->nrof;
           tmp->nrof += op->nrof;
           if (object *pl = tmp->visible_to ())
             esrv_update_item (UPD_NROF, pl, tmp);
-          adjust_weight (this, op->total_weight ());
+          adjust_weight (this, oweight, tmp->weight * tmp->nrof);
           op->destroy ();
           op = tmp;
           goto inserted;
         }
   op->flag [FLAG_REMOVED] = 0;
   if (object *pl = op->visible_to ())
     esrv_send_item (pl, op);
-  adjust_weight (this, op->total_weight ());
+  adjust_weight (this, 0, op->total_weight ());
 inserted:
   /* reset the light list and los of the players on the map */
   if (op->glow_radius && is_on_map ())
     {
  * MSW 2001-07-08: Check all objects on space, not just those below
  * object being inserted.  insert_ob_in_map may not put new objects
  * on top.
  */
 int
-check_move_on (object *op, object *originator)
+check_move_on (object *op, object *originator, int flags)
 {
   if (op->flag [FLAG_NO_APPLY])
     return 0;
   object *tmp;
       /* Basically same logic as above, except now for actual apply. */
       if ((!op->move_type && tmp->move_on & MOVE_WALK) ||
           ((op->move_type & tmp->move_on) && (op->move_type & ~tmp->move_on & ~tmp->move_block) == 0))
         {
+          if ((flags & INS_NO_AUTO_EXIT)
+              && (tmp->type == EXIT || tmp->type == TELEPORTER
+                  || tmp->type == HOLE || tmp->type == TRAPDOOR)) //TODO: temporary, fix exits instead
+            continue;
           move_apply (tmp, op, originator);
           if (op->destroyed ())
             return 1;
 #if 1 // new algorithm
   // this works by putting x, y into 16 sectors, which
   // are not equal sized, but are a better approximation
   // then the old algorithm, and then using a mapping
   // table to map it into a direction value.
+  // basically, it maps these comparisons to each bit
+  // bit #3: x < 0
+  // bit #2: y < 0
+  // bit #1: x > y
+  // bit #0: x > 2y
   static const uint8 dir[16] = {
      4,  5,  4,  3,
      2,  1,  2,  3,
      6,  5,  6,  7,
   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;
     return contr->mark;
   else
     return 0;
 }
+// put marked object first in the inventory
+// this is used by identify-like spells so players can influence
+// the order a bit.
+void
+object::splay_marked ()
+{
+  if (object *marked = mark ())
+    splay (marked);
+}

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.330 by root, Sun Apr 18 14:01:33 2010 UTC vs. Revision 1.351 by elmex, Fri Jun 3 08:36:45 2011 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.330 by root, Sun Apr 18 14:01:33 2010 UTC vs.
Revision 1.351 by elmex, Fri Jun 3 08:36:45 2011 UTC