--- deliantra/server/include/object.h	2006/09/08 16:51:44	1.20
+++ deliantra/server/include/object.h	2006/09/11 23:33:29	1.29
@@ -64,10 +64,10 @@
  * that were in the can_apply area.  What is the point of having both
  * can_apply and will_apply?
  */
-#define WILL_APPLY_HANDLE       0x1
-#define WILL_APPLY_TREASURE     0x2
-#define WILL_APPLY_EARTHWALL    0x4
-#define WILL_APPLY_DOOR         0x8
+#define WILL_APPLY_HANDLE       0x01
+#define WILL_APPLY_TREASURE     0x02
+#define WILL_APPLY_EARTHWALL    0x04
+#define WILL_APPLY_DOOR         0x08
 #define WILL_APPLY_FOOD         0x10
 
 
@@ -78,10 +78,9 @@
 
 // these are not being copied
 ACC_CLASS (object)
-struct object_keep
+struct object_keep : refcounted
 {
   tag_t ACC (RW, count);		/* Unique object number for this object */
-  uint16 ACC (RW, refcount);	/* How many objects points to this object */
 
   /* These variables are not changed by copy_object() */
   struct pl *ACC (RW, contr);	/* Pointer to the player which control this object */
@@ -107,14 +106,9 @@
 };
 
 // these are being copied
-struct object_copy:attachable<object>
+struct object_copy : attachable<object>
 {
-  /* These get an extra add_refcount(), after having been copied by memcpy().
-   * All fields beow this point are automatically copied by memcpy.  If
-   * adding something that needs a refcount updated, make sure you modify
-   * copy_object to do so.  Everything below here also gets cleared
-   * by clear_object()
-   */
+  refptr<object> ACC (RW, owner);	/* Pointer to the object which controls this one */
   shstr ACC (RW, name);		/* The name of the object, obviously... */
   shstr ACC (RW, name_pl);	/* The plural name of the object */
   shstr ACC (RW, title);		/* Of foo, etc */
@@ -153,7 +147,6 @@
   sint8 ACC (RW, magic);		/* Any magical bonuses to this item */
   uint8 ACC (RW, state);		/* How the object was last drawn (animation) */
   sint32 ACC (RW, value);	/* How much money it is worth (or contains) */
-  sint16 ACC (RW, level);	/* Level of creature or object */
   /* Note that the last_.. values are sometimes used for non obvious
    * meanings by some objects, eg, sp penalty, permanent exp.
    */
@@ -162,13 +155,14 @@
   sint16 ACC (RW, last_grace);	/* as last_sp, except for grace */
   sint16 ACC (RW, last_eat);	/* How long since we last ate */
   sint16 ACC (RW, invisible);	/* How much longer the object will be invis */
+  sint16 ACC (RW, level);	/* Level of creature or object */
   uint8 ACC (RW, pick_up);	/* See crossfire.doc */
   sint8 ACC (RW, item_power);	/* power rating of the object */
   sint8 ACC (RW, gen_sp_armour);	/* sp regen penalty this object has (was last_heal) */
+  sint8 ACC (RW, glow_radius);	/* indicates the glow radius of the object */
   sint32 ACC (RW, weight);	/* Attributes of the object */
   sint32 ACC (RW, weight_limit);	/* Weight-limit of object */
   sint32 ACC (RW, carrying);	/* How much weight this object contains */
-  sint8 ACC (RW, glow_radius);	/* indicates the glow radius of the object */
   living ACC (RO, stats);	/* Str, Con, Dex, etc */
   sint64 ACC (RW, perm_exp);	/* Permanent exp */
   struct object *ACC (RW, current_weapon);	/* Pointer to the weapon currently used */
@@ -176,28 +170,24 @@
   uint32 ACC (RW, tooltype);	/* type of tool or build facility */
   sint8 body_info[NUM_BODY_LOCATIONS];	/* body info as loaded from the file */
   sint8 body_used[NUM_BODY_LOCATIONS];	/* Calculated value based on items equipped */
+  uint8 ACC (RW, will_apply);	/* See crossfire.doc */
   /* See the doc/Developers/objects for more info about body locations */
 
   /* Following mostly refers to fields only used for monsters */
-  struct object *ACC (RW, owner);	/* Pointer to the object which controls this one */
-  /* Owner should not be referred to directly - */
-  /* get_owner should be used instead. */
-  tag_t ACC (RW, ownercount);	/* What count the owner had (in case owner */
-  /* has been freed) */
+  tag_t ACC (RW, ownercount);	/* What count the owner had (in case owner has been freed) *///TODO: remove/fix
   struct object *ACC (RW, enemy);	/* Monster/player to follow even if not closest */
   struct object *ACC (RW, attacked_by);	/* This object start to attack us! only player & monster */
   tag_t ACC (RW, attacked_by_count);	/* the tag of attacker, so we can be sure */
   struct treasureliststruct *ACC (RW, randomitems);	/* Items to be generated */
-  uint16 ACC (RW, run_away);	/* Monster runs away if it's hp goes below this percentage. */
   struct object *ACC (RW, chosen_skill);	/* the skill chosen to use */
   uint32 ACC (RW, hide);		/* The object is hidden, not invisible */
   /* changes made by kholland@sunlab.cit.cornell.edu */
   /* allows different movement patterns for attackers */
   sint32 ACC (RW, move_status);	/* What stage in attack mode */
   uint16 ACC (RW, attack_movement);	/* What kind of attack movement */
-  uint8 ACC (RW, will_apply);	/* See crossfire.doc */
+  uint16 ACC (RW, run_away);	/* Monster runs away if it's hp goes below this percentage. */
   struct object *ACC (RW, spellitem);	/* Spell ability monster is choosing to use */
-  double ACC (RW, expmul);	/* needed experience = (calc_exp*expmul) - means some */
+  float ACC (RW, expmul);	/* needed experience = (calc_exp*expmul) - means some */
   /* races/classes can need less/more exp to gain levels */
 
   /* Spell related information, may be useful elsewhere
@@ -205,18 +195,18 @@
    * only used in spells.
    */
   sint16 ACC (RW, duration);	/* How long the spell lasts */
-  uint8 ACC (RW, duration_modifier);	/* how level modifies duration */
   sint16 ACC (RW, casting_time);	/* time left before spell goes off */
-  struct object *ACC (RW, spell);	/* Spell that was being cast */
   uint16 ACC (RW, start_holding);
+  struct object *ACC (RW, spell);	/* Spell that was being cast */
   char *ACC (RW, spellarg);
+  uint8 ACC (RW, duration_modifier);	/* how level modifies duration */
   uint8 ACC (RW, dam_modifier);	/* How going up in level effects damage */
   sint8 ACC (RW, range);		/* Range of the spell */
   uint8 ACC (RW, range_modifier);	/* How going up in level effects range  */
 
   /* Following are values used by any object */
-  struct archt *ACC (RW, arch);		/* Pointer to archetype */
-  struct archt *ACC (RW, other_arch);	/* Pointer used for various things - mostly used for what */
+  struct archetype *ACC (RW, arch);		/* Pointer to archetype */
+  struct archetype *ACC (RW, other_arch);	/* Pointer used for various things - mostly used for what */
   /* this objects turns into or what this object creates */
   uint32 flags[4];		/* various flags */
   uint16 ACC (RW, animation_id);		/* An index into the animation array */
@@ -237,12 +227,82 @@
 
 struct object : zero_initialised, object_keep, object_copy, object_pod
 {
-  static bool can_merge (object * op1, object * op2);
+  static object *create ();
+  void free (bool free_inventory = false);
+
+  static void free_mortals ();
+  static bool can_merge (object *op1, object *op2);
 
   void clear ();
-  void clone (object * destination);
+  void clone (object *destination);
+
+  void set_owner (object *owner);
+  object *get_owner ();
+
+  // fully recursive iterator
+  struct iterator_base
+  {
+    object *item;
+
+    iterator_base (object *item)
+    : item(item)
+    {
+    }
+
+    operator object *() const { return item; }
+
+    object *operator ->() const { return  item; }
+    object &operator * () const { return *item; }
+  };
+
+  struct deep_iterator : iterator_base
+  {
+    deep_iterator (object *op) : iterator_base (op) { }
+
+    void next ();
+    object *operator ++(   ) { next (); return item; }
+    object *operator ++(int) { object *i = item; next (); return i; }
+  };
+
+  object *begin ()
+  {
+    return this->inv ? this->inv : end ();
+  }
+
+  object *end ()
+  {
+    return this->below;
+  }
+
+protected:
+  friend struct archetype;
+
+  void link ();
+  void unlink ();
+
+  object ();
+  ~object ();
 };
 
+#define get_object() object::create ()
+#define free_object(op) (op)->free (0)
+#define free_object2(op, free_inv) (op)->free (free_inv)
+#define clear_owner(op) (op)->owner = 0
+#define copy_owner(op,other) (op)->owner = (other)->owner
+#define clear_object(op) (op)->clear ()
+
+static inline object *
+get_owner (object *op)
+{
+  return op->get_owner ();
+}
+
+static inline void
+set_owner (object *op, object *owner)
+{
+  op->set_owner (owner);
+}
+
 #define CAN_MERGE(op1,op2) ((op1)->value == (op2)->value && (op1)->name == (op2)->name && object::can_merge ((op1), (op2)))
 
 typedef struct oblnk
@@ -269,18 +329,21 @@
  */
 
 ACC_CLASS(archetype)
-struct archt : zero_initialised
+struct archetype : zero_initialised
 {
+  archetype ();
+  ~archetype ();
+
   shstr ACC (RW, name);			/* More definite name, like "generate_kobold" */
-  struct archt *ACC (RW, next);		/* Next archetype in a linked list */
-  struct archt *ACC (RW, head);		/* The main part of a linked object */
-  struct archt *ACC (RW, more);		/* Next part of a linked object */
+  struct archetype *ACC (RW, next);		/* Next archetype in a linked list */
+  struct archetype *ACC (RW, head);		/* The main part of a linked object */
+  struct archetype *ACC (RW, more);		/* Next part of a linked object */
   object ACC (RO, clone);			/* An object from which to do copy_object() */
   uint32 ACC (RW, editable);		/* editable flags (mainly for editor) */
   sint8 ACC (RW, tail_x), ACC (RW, tail_y);		/* Where the lower right most portion of the object is
 				 * in comparison to the head.
 				 */
-} archetype;
+};
 
 extern object *objects;
 extern object *active_objects;