--- deliantra/server/include/object.h	2006/09/08 16:51:44	1.20
+++ deliantra/server/include/object.h	2006/09/14 18:13:02	1.37
@@ -58,19 +58,25 @@
   shstr key, value;
 };
 
+struct UUID
+{
+  uint64 seq;
+};
+
+extern void init_uuid ();
+extern UUID gen_uuid ();
 
 /* Definition for WILL_APPLY values.  Replaces having harcoded values
  * sprinkled in the code.  Note that some of these also replace fields
  * 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
 
-
 /* However, if you're keeping a pointer of some sort, you probably
  * don't just want it copied, so you'll need to add to common/object.C,
  * e.g. copy_object.
@@ -78,10 +84,10 @@
 
 // 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 */
+  tag_t ACC (RW, count);		/* Generation count for this object */
+  UUID uuid;                            // Unique Identifier, survives saves etc.
 
   /* These variables are not changed by copy_object() */
   struct pl *ACC (RW, contr);	/* Pointer to the player which control this object */
@@ -102,19 +108,13 @@
 				 * This is typically the container that the object is in.
 				 */
   struct object *ACC (RW, more);	/* Pointer to the rest of a large body of objects */
-  struct object *ACC (RW, head);	/* Points to the main object of a large body */
+  struct object *head;	/* Points to the main object of a large body */ // NO ACC, perl semantics are different
   struct mapstruct *ACC (RW, map);	/* Pointer to the map in which this object is present */
 };
 
 // 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()
-   */
   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 */
@@ -127,16 +127,23 @@
   /* To get put into books and the like. */
   shstr ACC (RW, materialname);	/* specific material name */
   shstr ACC (RW, custom_name);	/* Custom name assigned by player */
+  refptr<object> ACC (RW, owner);	/* Pointer to the object which controls this one */
+  refptr<object> ACC (RW, enemy);	/* Monster/player to follow even if not closest */
+  refptr<object> ACC (RW, attacked_by);	/* This object start to attack us! only player & monster */
+  refptr<object> ACC (RW, chosen_skill);	/* the skill chosen to use */
+  refptr<object> ACC (RW, spellitem);	/* Spell ability monster is choosing to use */
+  refptr<object> ACC (RW, spell);	/* Spell that was being cast */
+  refptr<object> ACC (RW, current_weapon);	/* Pointer to the weapon currently used */
 };
 
 // these are being copied and also cleared
 struct object_pod
 {
+  New_Face *ACC (RW, face);	/* Face with colors */
   sint16 ACC (RW, x), ACC (RW, y);	/* Position in the map for this object */
   float ACC (RW, speed);		/* The overall speed of this object */
   float ACC (RW, speed_left);	/* How much speed is left to spend this round */
   uint32 ACC (RW, nrof);		/* How many of the objects */
-  New_Face *ACC (RW, face);	/* Face with colors */
   sint8 ACC (RW, direction);	/* Means the object is moving that way. */
   sint8 ACC (RW, facing);	/* Object is oriented/facing that way. */
 
@@ -153,7 +160,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,42 +168,30 @@
   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 */
   uint32 ACC (RW, weapontype);	/* type of weapon */
   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 */
+  living ACC (RO, stats);	/* Str, Con, Dex, etc */
   /* 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) */
-  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 */
-  struct object *ACC (RW, spellitem);	/* Spell ability monster is choosing to use */
-  double ACC (RW, expmul);	/* needed experience = (calc_exp*expmul) - means some */
+  uint16 ACC (RW, run_away);	/* Monster runs away if it's hp goes below this percentage. */
+  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 +199,19 @@
    * 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);
-  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  */
+  char *ACC (RW, spellarg);
 
   /* 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 treasureliststruct *ACC (RW, randomitems);	/* Items to be generated */
+  struct archetype *ACC (RW, arch);		/* Pointer to archetype */
+  struct archetype *ACC (RW, other_arch);	/* Pointer used for various things - mostly used for what */
+  key_value *key_values;	/* Fields not explictly known by the loader. */
   /* 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 */
@@ -224,6 +219,7 @@
   uint8 ACC (RW, last_anim);		/* last sequence used to draw face */
   sint32 ACC (RW, elevation);		/* elevation of this terrain - not currently used */
   uint8 ACC (RW, smoothlevel);		/* how to smooth this square around */
+  uint8 ACC (RW, will_apply);	/* See crossfire.doc */
 
   MoveType ACC (RW, move_type);		/* Type of movement this object uses */
   MoveType ACC (RW, move_block);		/* What movement types this blocks */
@@ -232,17 +228,99 @@
   MoveType ACC (RW, move_off);		/* Move types affected moving off this space */
   MoveType ACC (RW, move_slow);		/* Movement types this slows down */
   float ACC (RW, move_slow_penalty);	/* How much this slows down the object */
-  key_value *key_values;	/* Fields not explictly known by the loader. */
 };
 
 struct object : zero_initialised, object_keep, object_copy, object_pod
 {
-  static bool can_merge (object * op1, object * op2);
+  typedef unordered_vector<object *> vector;
+
+  static vector mortals;
+  static vector active;  // active objects, not yet used
+  static vector objects; // not used yet, use first->next->...
+  static object *first;  // will be replaced by "objects"
+
+  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 instantiate ()
+  {
+    if (!uuid.seq) // HACK
+      uuid = gen_uuid ();
+
+    attachable<object>::instantiate ();
+  }
+
+  void set_owner (object *owner);
+
+  // info must hold 256 * 3 bytes currently
+  const char *debug_desc (char *info) const;
+  const char *debug_desc () const;
+
+  // fully recursive iterator
+  struct iterator_base
+  {
+    object *item;
+
+    iterator_base (object *container)
+    : item (container)
+    {
+    }
+
+    operator object *() const { return item; }
+
+    object *operator ->() const { return  item; }
+    object &operator * () const { return *item; }
+  };
+
+  // depth-first recursive iterator
+  struct depth_iterator : iterator_base
+  {
+    depth_iterator (object *container);
+    void next ();
+    object *operator ++(   ) { next (); return item; }
+    object *operator ++(int) { object *i = item; next (); return i; }
+  };
+
+  object *begin ()
+  {
+    return this;
+  }
+
+  object *end ()
+  {
+    return this;
+  }
+
+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 get_owner(op) (op)->owner
+#define clear_object(op) (op)->clear ()
+
+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 +347,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;