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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.119 by root, Fri Jan 19 18:06:51 2007 UTC vs.
Revision 1.147 by root, Sat May 12 16:06:42 2007 UTC

 /*
- * CrossFire, A Multiplayer game for X-windows
+ * CrossFire, A Multiplayer game
  *
  * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
  * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
  * Copyright (C) 1992 Frank Tore Johansen
  *
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <object.h>
 #include <funcpoint.h>
+#include <sproto.h>
 #include <loader.h>
 #include <bitset>
 int nrofallocobjects = 0;
 sum_weight (object *op)
 {
   long sum;
   object *inv;
-  for (sum = 0, inv = op->inv; inv != NULL; inv = inv->below)
+  for (sum = 0, inv = op->inv; inv; inv = inv->below)
     {
       if (inv->inv)
         sum_weight (inv);
       sum += inv->carrying + inv->weight * (inv->nrof ? inv->nrof : 1);
     }
   if (op->type == CONTAINER && op->stats.Str)
     sum = (sum * (100 - op->stats.Str)) / 100;
 /*
  * Used by: Crossedit: dump. Server DM commands: dumpbelow, dump.
  *      Some error messages.
  * The result of the dump is stored in the static global errmsg array.
  */
 char *
 dump_object (object *op)
 {
   if (!op)
     return strdup ("[NULLOBJ]");
   object_freezer freezer;
-  save_object (freezer, op, 1);
+  op->write (freezer);
   return freezer.as_string ();
 }
 /*
  * get_nearest_part(multi-object, object 2) returns the part of the
     owner = owner->owner;
   this->owner = owner;
 }
+bool
+object::change_weapon (object *ob)
+{
+  if (current_weapon == ob)
+    return true;
+  if (chosen_skill)
+    chosen_skill->flag [FLAG_APPLIED] = false;
+  current_weapon = ob;
+  chosen_skill = !ob || ob->type == SKILL ? ob : find_skill_by_name (this, ob->skill);
+  if (chosen_skill)
+    chosen_skill->flag [FLAG_APPLIED] = true;
+  update_stats ();
+  if (ob)
+    {
+      // now check wether any body locations became invalid, in which case
+      // we cannot apply the weapon at the moment.
+      for (int i = 0; i < NUM_BODY_LOCATIONS; ++i)
+        if (slot[i].used < 0)
+          {
+            current_weapon = chosen_skill = 0;
+            update_stats ();
+            new_draw_info_format (NDI_UNIQUE, 0, this,
+                                  "You try to balance your applied items all at once, but the %s is too much. "
+                                  "You need to unapply some items first.", &ob->name);
+            return false;
+          }
+      new_draw_info_format (NDI_UNIQUE, 0, this, "You switch to your %s.", &ob->name);
+    }
+  else
+    new_draw_info_format (NDI_UNIQUE, 0, this, "You unwield your weapons.");
+  return true;
+}
 /* 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 != 0;)
+  for (key_value *i = op->key_values; i; )
     {
       key_value *next = i->next;
       delete i;
       i = next;
     }
   op->key_values = 0;
 }
-/*
+object &
- * copy_to first frees everything allocated by the dst object,
+object::operator =(const object &src)
- * 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,
- * if the first object is freed, the pointers in the new object
- * will point at garbage.
- */
-void
-object::copy_to (object *dst)
 {
-  bool is_freed   = QUERY_FLAG (dst, FLAG_FREED);
+  bool is_freed   = flag [FLAG_FREED];
-  bool is_removed = QUERY_FLAG (dst, FLAG_REMOVED);
+  bool is_removed = flag [FLAG_REMOVED];
-  *(object_copy *)dst = *this;
+  *(object_copy *)this = src;
-  if (is_freed)
+  flag [FLAG_FREED]   = is_freed;
-    SET_FLAG (dst, FLAG_FREED);
+  flag [FLAG_REMOVED] = is_removed;
-  if (is_removed)
-    SET_FLAG (dst, FLAG_REMOVED);
-  if (speed < 0)
-    dst->speed_left = speed_left - rndm ();
   /* Copy over key_values, if any. */
-  if (key_values)
+  if (src.key_values)
     {
       key_value *tail = 0;
-      key_value *i;
-      dst->key_values = 0;
+      key_values = 0;
-      for (i = key_values; i; i = i->next)
+      for (key_value *i = src.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)
+          if (!key_values)
             {
-              dst->key_values = new_link;
+              key_values = new_link;
               tail = new_link;
             }
           else
             {
               tail->next = new_link;
               tail = new_link;
             }
         }
     }
+}
+/*
+ * 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,
+ * if the first object is freed, the pointers in the new object
+ * will point at garbage.
+ */
+void
+object::copy_to (object *dst)
+{
+  *dst = *this;
+  if (speed < 0)
+    dst->speed_left = speed_left - rndm ();
   dst->set_speed (dst->speed);
+}
+void
+object::instantiate ()
+{
+  if (!uuid.seq) // HACK
+    uuid = gen_uuid ();
+  speed_left = -0.1f;
+  /* copy the body_info to the body_used - this is only really
+   * need for monsters, but doesn't hurt to do it for everything.
+   * by doing so, when a monster is created, it has good starting
+   * values for the body_used info, so when items are created
+   * for it, they can be properly equipped.
+   */
+  for (int i = NUM_BODY_LOCATIONS; i--; )
+    slot[i].used = slot[i].info;
+  attachable::instantiate ();
 }
 object *
 object::clone ()
 {
  * UP_OBJ_FACE: only the objects face has changed.
  */
 void
 update_object (object *op, int action)
 {
-  MoveType move_on, move_off, move_block, move_slow;
   if (op == NULL)
     {
       /* this should never happen */
       LOG (llevDebug, "update_object() called for NULL object.\n");
       return;
   face = blank_face;
 }
 object::~object ()
 {
-  if (index)
-    unlink ();
+  unlink ();
   free_key_values (this);
 }
 static int object_count;
   objects.insert (this);
 }
 void object::unlink ()
 {
-  assert (index);//D
+  if (!index)
+    return;
   objects.erase (this);
   refcnt_dec ();
 }
 void
    * drop on that space.
    */
   if (!drop_to_ground
       || !map
       || map->in_memory != MAP_IN_MEMORY
+      || map->nodrop
       || ms ().move_block == MOVE_ALL)
     {
       while (inv)
         {
           inv->destroy_inv (drop_to_ground);
  *   This function removes the object op from the linked list of objects
  *   which it is currently tied to.  When this function is done, the
  *   object will have no environment.  If the object previously had an
  *   environment, the x and y coordinates will be updated to
  *   the previous environment.
- *   Beware: This function is called from the editor as well!
  */
 void
-object::remove_slow ()
+object::do_remove ()
 {
   object *tmp, *last = 0;
   object *otmp;
   if (QUERY_FLAG (this, FLAG_REMOVED))
     }
   else if (map)
     {
       if (type == PLAYER)
         {
+          // leaving a spot always closes any open container on the ground
+          if (container && !container->env)
+            // this causes spurious floorbox updates, but it ensures
+            // that the CLOSE event is being sent.
+            close_container ();
           --map->players;
           map->touch ();
         }
       map->dirty = true;
           return top;
         }
     }
   return 0;
+}
+void
+object::expand_tail ()
+{
+  if (more)
+    return;
+  object *prev = this;
+  for (archetype *at = arch->more; at; at = at->more)
+    {
+      object *op = arch_to_object (at);
+      op->name    = name;
+      op->name_pl = name_pl;
+      op->title   = title;
+      op->head = this;
+      prev->more = op;
+      prev = op;
+    }
 }
 /*
  * same as insert_ob_in_map except it handles separate coordinates and does a clean
  * job preparing multi-part monsters.
  *   just 'op' otherwise
  */
 object *
 insert_ob_in_map (object *op, maptile *m, object *originator, int flag)
 {
+  assert (!op->flag [FLAG_FREED]);
   object *tmp, *top, *floor = NULL;
-  if (QUERY_FLAG (op, FLAG_FREED))
-    {
-      LOG (llevError, "Trying to insert freed object!\n");
-      return NULL;
-    }
-  if (!QUERY_FLAG (op, FLAG_REMOVED))
-    LOG (llevError, "Trying to insert already inserted object %s\n", op->debug_desc ());
   op->remove ();
-  if (!m)
+#if 0
-    {
+  if (!m->active != !op->active)
-      char *dump = dump_object (op);
+    if (m->active)
-      LOG (llevError, "Trying to insert in null-map!\n%s\n", dump);
+      op->activate_recursive ();
-      free (dump);
+    else
-      return op;
+      op->deactivate_recursive ();
-    }
+#endif
   if (out_of_map (m, op->x, op->y))
     {
-      char *dump = dump_object (op);
-      LOG (llevError, "Trying to insert object outside the map.\n%s\n", dump);
+      LOG (llevError, "Trying to insert object outside the map.\n%s\n", op->debug_desc ());
 #ifdef MANY_CORES
       /* Better to catch this here, as otherwise the next use of this object
        * is likely to cause a crash.  Better to find out where it is getting
        * improperly inserted.
        */
       abort ();
 #endif
-      free (dump);
       return op;
     }
   if (object *more = op->more)
     {
            * looks like instead of lots of conditions here.
            * makes things faster, and effectively the same result.
            */
           /* Have object 'fall below' other objects that block view.
-           * Unless those objects are exits, type 66
+           * Unless those objects are exits.
            * If INS_ON_TOP is used, don't do this processing
            * Need to find the object that in fact blocks view, otherwise
            * stacking is a bit odd.
            */
           if (!(flag & INS_ON_TOP)
               && ms.flags () & P_BLOCKSVIEW
-              && (op->face && !op->face->visibility))
+              && (op->face && !faces [op->face].visibility))
             {
               for (last = top; last != floor; last = last->below)
                 if (QUERY_FLAG (last, FLAG_BLOCKSVIEW) && (last->type != EXIT))
                   break;
 }
 object *
 object::insert_at (object *where, object *originator, int flags)
 {
-  where->map->insert (this, where->x, where->y, originator, flags);
+  return where->map->insert (this, where->x, where->y, originator, flags);
 }
 /*
  * get_split_ob(ob,nr) splits up ob into two parts.  The part which
  * is returned contains nr objects, and the remaining parts contains
  * the amount of an object.  If the amount reaches 0, the object
  * is subsequently removed and freed.
  *
  * Return value: 'op' if something is left, NULL if the amount reached 0
  */
 object *
 decrease_ob_nr (object *op, uint32 i)
 {
   object *tmp;
 /*
  * add_weight(object, weight) adds the specified weight to an object,
  * and also updates how much the environment(s) is/are carrying.
  */
 void
 add_weight (object *op, signed long weight)
 {
   while (op != NULL)
     {
  *   inside the object environment.
  *
  * The function returns now pointer to inserted item, and return value can
  * be != op, if items are merged. -Tero
  */
 object *
 object::insert (object *op)
 {
   object *tmp, *otmp;
           if ((!op->move_type && tmp->move_slow & MOVE_WALK) ||
               ((op->move_type & tmp->move_slow) && (op->move_type & ~tmp->move_slow & ~tmp->move_block) == 0))
             {
               float
-                diff = tmp->move_slow_penalty * FABS (op->speed);
+                diff = tmp->move_slow_penalty * fabs (op->speed);
               if (op->type == PLAYER)
                 if ((QUERY_FLAG (tmp, FLAG_IS_HILLY) && find_skill_by_number (op, SK_CLIMBING)) ||
                     (QUERY_FLAG (tmp, FLAG_IS_WOODED) && find_skill_by_number (op, SK_WOODSMAN)))
                   diff /= 4.0;
     }
   if (!index)
     return -1;
-  return altern[RANDOM () % index];
+  return altern [rndm (index)];
 }
 /*
  * find_first_free_spot(archetype, maptile, x, y) works like
  * find_free_spot(), but it will search max number of squares.
 {
   arr += begin;
   end -= begin;
   while (--end)
-    swap (arr [end], arr [RANDOM () % (end + 1)]);
+    swap (arr [end], arr [rndm (end + 1)]);
 }
 /* new function to make monster searching more efficient, and effective!
  * This basically returns a randomized array (in the passed pointer) of
  * the spaces to find monsters.  In this way, it won't always look for
     insert_ob_in_ob (object_create_clone (item), dst);
   return dst;
 }
-/* GROS - Creates an object using a string representing its content.         */
-/* Basically, we save the content of the string to a temp file, then call    */
-/* load_object on it. I admit it is a highly inefficient way to make things, */
-/* but it was simple to make and allows reusing the load_object function.    */
-/* Remember not to use load_object_str in a time-critical situation.         */
-/* Also remember that multiparts objects are not supported for now.          */
-object *
-load_object_str (const char *obstr)
-{
-  object *op;
-  char filename[MAX_BUF];
-  sprintf (filename, "%s/cfloadobstr2044", settings.tmpdir);
-  FILE *tempfile = fopen (filename, "w");
-  if (tempfile == NULL)
-    {
-      LOG (llevError, "Error - Unable to access load object temp file\n");
-      return NULL;
-    }
-  fprintf (tempfile, obstr);
-  fclose (tempfile);
-  op = object::create ();
-  object_thawer thawer (filename);
-  if (thawer)
-    load_object (thawer, op, 0);
-  LOG (llevDebug, " load str completed, object=%s\n", &op->name);
-  CLEAR_FLAG (op, FLAG_REMOVED);
-  return op;
-}
 /* This returns the first object in who's inventory that
  * has the same type and subtype match.
  * returns NULL if no match.
  */
 object *
     if (link->key == canonical_key)
       return link->value;
   return 0;
 }
 /*
  * Updates the canonical_key in op to value.
  *
  * canonical_key is a shared string (value doesn't have to be).
 {
   char flagdesc[512];
   char info2[256 * 4];
   char *p = info;
-  p += snprintf (p, 512, "{cnt:%d,uuid:<1,%" PRIx64 ">,name:\"%s\"%s%s,flags:[%s],type:%d}",
+  p += snprintf (p, 512, "{cnt:%d,uuid:<1.%" PRIx64 ">,name:\"%s\"%s%s,flags:[%s],type:%d}",
                  count, uuid.seq,
                  &name,
                  title ? "\",title:\"" : "",
                  title ? (const char *)title : "",
                  flag_desc (flagdesc, 512), type);
 }
 const char *
 object::debug_desc () const
 {
-  static char info[256 * 4];
+  static char info[3][256 * 4];
+  static int info_idx;
-  return debug_desc (info);
+  return debug_desc (info [++info_idx % 3]);
 }
-const char *
+struct region *
-object::debug_desc2 () const
+object::region () const
 {
-  static char info[256 * 4];
+  return map ? map->region (x, y)
-  return debug_desc (info);
+             : region::default_region ();
 }
+const materialtype_t *
+object::dominant_material () const
+{
+  if (materialtype_t *mat = name_to_material (materialname))
+    return mat;
+  // omfg this is slow, this has to be temporary :)
+  shstr unknown ("unknown");
+  return name_to_material (unknown);
+}
+void
+object::open_container (object *new_container)
+{
+  if (container == new_container)
+    return;
+  if (object *old_container = container)
+    {
+      if (INVOKE_OBJECT (CLOSE, old_container, ARG_OBJECT (this)))
+        return;
+#if 0
+      // remove the "Close old_container" object.
+      if (object *closer = old_container->inv)
+        if (closer->type == CLOSE_CON)
+          closer->destroy ();
+#endif
+      old_container->flag [FLAG_APPLIED] = 0;
+      container = 0;
+      esrv_update_item (UPD_FLAGS, this, old_container);
+      new_draw_info_format (NDI_UNIQUE, 0, this, "You close %s.", query_name (old_container));
+    }
+  if (new_container)
+    {
+      if (INVOKE_OBJECT (OPEN, new_container, ARG_OBJECT (this)))
+        return;
+      // TODO: this does not seem to serve any purpose anymore?
+#if 0
+      // insert the "Close Container" object.
+      if (archetype *closer = new_container->other_arch)
+        {
+          object *closer = arch_to_object (new_container->other_arch);
+          closer->flag [FLAG_NO_MAP_SAVE] = 1;
+          new_container->insert (closer);
+        }
+#endif
+      new_draw_info_format (NDI_UNIQUE, 0, this, "You open %s.", query_name (new_container));
+      new_container->flag [FLAG_APPLIED] = 1;
+      container = new_container;
+      esrv_update_item (UPD_FLAGS, this, new_container);
+      esrv_send_inventory (this, new_container);
+    }
+}

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.119 by root, Fri Jan 19 18:06:51 2007 UTC vs. Revision 1.147 by root, Sat May 12 16:06:42 2007 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.119 by root, Fri Jan 19 18:06:51 2007 UTC vs.
Revision 1.147 by root, Sat May 12 16:06:42 2007 UTC