--- deliantra/server/include/object.h	2006/09/12 01:26:07	1.31
+++ deliantra/server/include/object.h	2006/12/21 01:33:50	1.61
@@ -18,12 +18,14 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    The authors can be reached via e-mail at crossfire-devel@real-time.com
+    The authors can be reached via e-mail at crossfire@schmorp.de
 */
 
 #ifndef OBJECT_H
 #define OBJECT_H
 
+#include <bitset>
+
 #include "cfperl.h"
 #include "shstr.h"
 
@@ -58,6 +60,19 @@
   shstr key, value;
 };
 
+struct UUID
+{
+  uint64 seq;
+
+  UUID () { }
+  UUID (uint64 seq) : seq(seq) { }
+  operator uint64() { return seq; }
+  void operator =(uint64 seq) { this->seq = seq; }
+};
+
+extern void init_uuid ();
+extern UUID gen_uuid ();
+extern const uint64 UUID_SKIP;
 
 /* Definition for WILL_APPLY values.  Replaces having harcoded values
  * sprinkled in the code.  Note that some of these also replace fields
@@ -70,67 +85,78 @@
 #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.
+ * e.g. ->copy_to ()
  */
 
+typedef refptr<object> object_ptr;
+typedef refptr<archetype> arch_ptr;
+
 // these are not being copied
 ACC_CLASS (object)
 struct object_keep : refcounted
 {
-  tag_t ACC (RW, count);		/* Unique object number for this object */
+  /* These variables are not changed by ->copy_to */
+
+  tag_t ACC (RW, count);	/* Generation count for this object */
+  UUID ACC (RW, 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 */
-  struct object *ACC (RW, next);	/* Pointer to the next object in the free/used list */
-  struct object *ACC (RW, prev);	/* Pointer to the previous object in the free/used list */
-  struct object *ACC (RW, active_next);	/* Next & previous object in the 'active' */
-  struct object *ACC (RW, active_prev);	/* List.  This is used in process_events */
-  /* so that the entire object list does not */
-  /* need to be gone through. */
-  struct object *ACC (RW, below);	/* Pointer to the object stacked below this one */
-  struct object *ACC (RW, above);	/* Pointer to the object stacked above this one */
-  /* Note: stacked in the *same* environment */
-  struct object *inv;			/* Pointer to the first object in the inventory */
-  struct object *ACC (RW, container);	/* Current container being used.  I think this
-					 * is only used by the player right now.
-					 */
-  struct object *ACC (RW, env);	/* Pointer to the object which is the environment.
+  player *ACC (RW, contr);	/* Pointer to the player which control this object */
+  object *ACC (RW, next);	/* Pointer to the next object in the free/used list */
+  object *ACC (RW, prev);	/* Pointer to the previous object in the free/used list */
+  object *ACC (RW, active_next);/* Next & previous object in the 'active' */
+  object *ACC (RW, active_prev);/* List.  This is used in process_events */
+                                /* so that the entire object list does not */
+                                /* need to be gone through. */
+  object *ACC (RW, below);	/* Pointer to the object stacked below this one */
+  object *ACC (RW, above);	/* Pointer to the object stacked above this one */
+                                /* Note: stacked in the *same* environment */
+  object *inv;			/* Pointer to the first object in the inventory */
+  object *ACC (RW, container);	/* Current container being used.  I think this
+				 * is only used by the player right now.
+				 */
+  object *ACC (RW, env);	/* Pointer to the object which is the environment.
 				 * 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 *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 */
+  object *ACC (RW, more);	/* Pointer to the rest of a large body of objects */
+  object *head;			/* Points to the main object of a large body */ // NO ACC, perl semantics are different
+  maptile *ACC (RW, map);	/* Pointer to the map in which this object is present */
+  client_container *seen_by;    // seen by which player/container currently?
 };
 
 // these are being copied
 struct object_copy : attachable<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 */
+  shstr ACC (RW, title);	/* Of foo, etc */
   shstr ACC (RW, race);		/* human, goblin, dragon, etc */
   shstr ACC (RW, slaying);	/* Which race to do double damage to */
   /* If this is an exit, this is the filename */
-  shstr ACC (RW, skill);		/* Name of the skill this object uses/grants */
+  shstr ACC (RW, skill);	/* Name of the skill this object uses/grants */
   shstr ACC (RW, msg);		/* If this is a book/sign/magic mouth/etc */
   shstr ACC (RW, lore);		/* Obscure information about this object, */
   /* 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 */
+  object_ptr ACC (RW, owner);	/* Pointer to the object which controls this one */
+  object_ptr ACC (RW, enemy);	/* Monster/player to follow even if not closest */
+  object_ptr ACC (RW, attacked_by);	/* This object start to attack us! only player & monster */
+  object_ptr ACC (RW, chosen_skill);	/* the skill chosen to use */
+  object_ptr ACC (RW, spellitem);	/* Spell ability monster is choosing to use */
+  object_ptr ACC (RW, spell);	/* Spell that was being cast */
+  object_ptr 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);	/* 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 */
+  uint32 ACC (RW, nrof);	/* How many of the objects */
   sint8 ACC (RW, direction);	/* Means the object is moving that way. */
   sint8 ACC (RW, facing);	/* Object is oriented/facing that way. */
 
@@ -140,12 +166,12 @@
   uint16 ACC (RW, client_type);	/* Public type information.  see doc/Developers/objects */
   sint16 resist[NROFATTACKS];	/* Resistance adjustments for attacks */
   uint32 ACC (RW, attacktype);	/* Bitmask of attacks this object does */
-  uint32 ACC (RW, path_attuned);	/* Paths the object is attuned to */
+  uint32 ACC (RW, path_attuned);/* Paths the object is attuned to */
   uint32 ACC (RW, path_repelled);	/* Paths the object is repelled from */
   uint32 ACC (RW, path_denied);	/* Paths the object is denied access to */
   uint16 ACC (RW, material);	/* What materials this object consist of */
-  sint8 ACC (RW, magic);		/* Any magical bonuses to this item */
-  uint8 ACC (RW, state);		/* How the object was last drawn (animation) */
+  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) */
   /* Note that the last_.. values are sometimes used for non obvious
    * meanings by some objects, eg, sp penalty, permanent exp.
@@ -158,35 +184,26 @@
   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, 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, weight_limit);/* Weight-limit of object */
   sint32 ACC (RW, carrying);	/* How much weight this object contains */
-  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 */
-  uint8 ACC (RW, will_apply);	/* See crossfire.doc */
+  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 */
-  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 */
-  struct object *ACC (RW, chosen_skill);	/* the skill chosen to use */
-  uint32 ACC (RW, hide);		/* The object is hidden, not invisible */
+  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 */
   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 */
   float ACC (RW, expmul);	/* needed experience = (calc_exp*expmul) - means some */
   /* races/classes can need less/more exp to gain levels */
 
@@ -195,49 +212,111 @@
    * only used in spells.
    */
   sint16 ACC (RW, duration);	/* How long the spell lasts */
-  sint16 ACC (RW, casting_time);	/* time left before spell goes off */
+  sint16 ACC (RW, casting_time);/* time left before spell goes off */
   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 */
+  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 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 */
-  uint8 ACC (RW, anim_speed);		/* ticks between animation-frames */
-  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 */
-
-  MoveType ACC (RW, move_type);		/* Type of movement this object uses */
-  MoveType ACC (RW, move_block);		/* What movement types this blocks */
-  MoveType ACC (RW, move_allow);		/* What movement types explicitly allowd */
-  MoveType ACC (RW, move_on);		/* Move types affected moving on to this space */
-  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 */
+  treasurelist *ACC (RW, randomitems);	/* Items to be generated */
+  arch_ptr ACC (RW, arch);	/* Pointer to archetype */
+  arch_ptr ACC (RW, other_arch);/* Pointer used for various things - mostly used for what */
   key_value *key_values;	/* Fields not explictly known by the loader. */
+  std::bitset<NUM_FLAGS> flags; /* various flags */
+  uint16 ACC (RW, animation_id);/* An index into the animation array */
+  uint8 ACC (RW, anim_speed);	/* ticks between animation-frames */
+  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 */
+  MoveType ACC (RW, move_allow);/* What movement types explicitly allowd */
+  MoveType ACC (RW, move_on);	/* Move types affected moving on to this space */
+  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 */
 };
 
 struct object : zero_initialised, object_keep, object_copy, object_pod
 {
+  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);
+  void copy_to (object *dst);
+  object *clone (); // create + copy_to
+  void destroy (bool destroy_inventory = false);
+  void remove ();
+  object *insert (object *item); // insert into inventory
 
   static void free_mortals ();
-  static bool can_merge (object *op1, object *op2);
+  static bool can_merge_slow (object *op1, object *op2);
+
+  // this is often used in time-critical code, so optimise
+  static bool can_merge (object *op1, object *op2)
+  {
+    return op1->value == op2->value
+        && op1->name  == op2->name
+        && can_merge_slow (op1, op2);
+  }
 
   void clear ();
-  void clone (object *destination);
+
+  bool destroyed () { return QUERY_FLAG (this, FLAG_FREED); }
 
   void set_owner (object *owner);
-  object *get_owner ();
+
+  void instantiate ()
+  {
+    if (!uuid.seq) // HACK
+      uuid = gen_uuid ();
+
+    attachable<object>::instantiate ();
+  }
+
+  // info must hold 256 * 3 bytes currently
+  const char *debug_desc (char *info) const;
+  const char *debug_desc () const;
+
+  bool is_weapon () const { return type == ARROW || type == BOW || type == WEAPON; }
+  bool is_armor  () const { return type == ARMOUR  || type == SHIELD || type == HELMET
+                                || type == CLOAK   || type == BOOTS  || type == GLOVES
+                                || type == BRACERS || type == GIRDLE; }
+  bool is_alive  () const { return (type == PLAYER
+                                    || flags [FLAG_MONSTER]
+                                    || (flags [FLAG_ALIVE] && !flags [FLAG_GENERATOR] && type != DOOR))
+                                   && !flags [FLAG_IS_A_TEMPLATE]; }
+  bool is_arrow  () const { return type == ARROW
+                                 || (type == SPELL_EFFECT
+                                     && (subtype == SP_BULLET || subtype == SP_MAGIC_MISSILE)); }
+
+  /* This return true if object has still randomitems which
+   * could be expanded.
+   */
+  bool has_random_items () const { return randomitems && !flags [FLAG_IS_A_TEMPLATE]; }
+
+  // returns the player that has this object in his inventory, or 0
+  object *in_player () const
+  {
+    for (object *op = env; op; op = op->env)
+      if (op->type == PLAYER)
+        return op;
+
+    return 0;
+  }
+
+  // returns the mapspace this object is in
+  mapspace &ms () const;
 
   // fully recursive iterator
   struct iterator_base
@@ -284,32 +363,10 @@
   ~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
 {				/* Used to link together several objects */
-  object *ob;
+  object_ptr ob;
   struct oblnk *next;
-  tag_t id;
 } objectlink;
 
 typedef struct oblinkpt
@@ -328,21 +385,26 @@
  * by the object structure
  */
 
-ACC_CLASS(archetype)
-struct archetype : zero_initialised
+ACC_CLASS (archetype)
+struct archetype : zero_initialised, refcounted
 {
   archetype ();
   ~archetype ();
 
-  shstr ACC (RW, name);			/* More definite name, like "generate_kobold" */
-  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.
-				 */
+  static archetype *find (const char *arch);
+
+  void hash_add (); // add to hastable
+  void hash_del (); // remove from hashtable
+
+  shstr ACC (RW, name);		       		/* More definite name, like "generate_kobold" */
+  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_to () */
+  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.
+						 */
 };
 
 extern object *objects;
@@ -353,7 +415,7 @@
 /* This returns TRUE if the object is something that
  * should be displayed in the look window
  */
-#define LOOK_OBJ(ob) (!ob->invisible && ob->type!=PLAYER && ob->type!=EVENT_CONNECTOR)
+#define LOOK_OBJ(ob) (!ob->invisible && ob->type != PLAYER && ob->type != EVENT_CONNECTOR)
 
 /* Used by update_object to know if the object being passed is
  * being added or removed.
@@ -404,3 +466,4 @@
 #define ARCH_SYMPTOM            "symptom"
 
 #endif
+