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

Comparing deliantra/server/common/object.C (file contents):
Revision 1.136 by root, Thu Mar 15 14:23:02 2007 UTC vs.
Revision 1.141 by root, Sun Apr 29 21:44:34 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
  *
   /* Everything passes, must be OK. */
   return 1;
 }
+void
+player::set_range (rangetype r)
+{
+  shoottype = r;
+}
 /*
  * sum_weight() is a recursive function which calculates the weight
  * an object is carrying.  It goes through in figures out how much
  * containers are carrying, and sums it up.
  */
  * 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
   if (flag [FLAG_IS_LINKED])
     remove_button_link (this);
   if (flag [FLAG_FRIENDLY])
-    {
-      remove_friendly_object (this);
+    remove_friendly_object (this);
-      if (type == GOLEM
-          && owner
-          && owner->type == PLAYER
-          && owner->contr->ranges[range_golem] == this)
-        owner->contr->ranges[range_golem] = 0;
-    }
   if (!flag [FLAG_REMOVED])
     remove ();
   destroy_inv (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)
     {
   tmp1->x = op->x;
   tmp1->y = op->y;
   insert_ob_in_map (tmp1, op->map, op, 0);
 }
-// XXX: function not returning object*
 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;

Diff Legend

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

Comparing deliantra/server/common/object.C (file contents): Revision 1.136 by root, Thu Mar 15 14:23:02 2007 UTC vs. Revision 1.141 by root, Sun Apr 29 21:44:34 2007 UTC

Diff Legend

Comparing deliantra/server/common/object.C (file contents):
Revision 1.136 by root, Thu Mar 15 14:23:02 2007 UTC vs.
Revision 1.141 by root, Sun Apr 29 21:44:34 2007 UTC