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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.333 by root, Thu Apr 22 03:53:40 2010 UTC vs.
Revision 1.345 by root, Sun May 1 16:58:15 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)
-             - weight_adjust_for (op, op->carrying);
-      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 carrying got %ld, expected %ld (%s)\n",
              (long long)sum, (long long)carrying, debug_desc ());
       carrying = sum;
       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.;
 object::~object ()
 {
   unlink ();
-  free_key_values (this);
+  kv.clear ();
 }
 void object::link ()
 {
   assert (!index);//D
       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 ();
 {
   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;
       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::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.333 by root, Thu Apr 22 03:53:40 2010 UTC vs. Revision 1.345 by root, Sun May 1 16:58:15 2011 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.333 by root, Thu Apr 22 03:53:40 2010 UTC vs.
Revision 1.345 by root, Sun May 1 16:58:15 2011 UTC