server/include/object.h

/*
 * CrossFire, A Multiplayer Online RPG
 *
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * Copyright (C) 2001 Mark Wedel & Crossfire Development Team
 * Copyright (C) 1992 Frank Tore Johansen
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * 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@schmorp.de
 */

#ifndef OBJECT_H
#define OBJECT_H

#include <bitset>

#include "cfperl.h"
#include "shstr.h"

typedef int tag_t;

#define NUM_BODY_LOCATIONS      12
#define BODY_ARMS               1

/* See common/item.c */

typedef struct Body_Locations
{
  const char *save_name;        /* Name used to load/save it to disk */
  const char *use_name;         /* Name used when describing an item we can use */
  const char *nonuse_name;      /* Name to describe objects we can't use */
} Body_Locations;

extern Body_Locations body_locations[NUM_BODY_LOCATIONS];

/*
 * Each object (this also means archetypes!) could have a few of these
 * "dangling" from it; this could also end up containing 'parse errors'.
 *
 * key and value are shared-strings.
 *
 * Please use get_ob_key_value(), set_ob_key_value() from object.c rather than
 * accessing the list directly.
 * Exception is if you want to walk this list for some reason.
 */
struct key_value
{
  key_value *next;
  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
 * that were in the can_apply area.  What is the point of having both
 * can_apply and will_apply?
 */
#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_to ()
 */

INTERFACE_CLASS (object)
// these are being copied
struct object_copy : attachable
{
  typedef bitset<NUM_FLAGS> flags_t;

  sint16 ACC (RW, x), ACC (RW, y);      /* Position in the map for this object */
  sint8 ACC (RW, direction);    /* Means the object is moving that way. */
  sint8 ACC (RW, facing);       /* Object is oriented/facing that way. */
  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, 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, 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 */
//  materialtype_t *ACC (RW, material); /* What material this object consists of */
  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 */
  arch_ptr ACC (RW, arch);      /* Pointer to archetype */
  arch_ptr ACC (RW, other_arch);/* Pointer used for various things - mostly used for what */

  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 */

  /* This next big block are basically used for monsters and equipment */
  uint8 ACC (RW, type);         /* PLAYER, BULLET, etc.  See define.h */
  uint8 ACC (RW, subtype);      /* subtype of object */
  uint16 ACC (RW, client_type); /* Public type information.  see doc/Developers/objects */
  sint16 ACC (RW, 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_repelled);       /* Paths the object is repelled from */
  uint32 ACC (RW, path_denied); /* Paths the object is denied access to */
  uint16 ACC (RW, materials);   /* What materials this object consists of */
  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.
   */
  sint32 ACC (RW, last_heal);   /* Last healed. Depends on constitution */
  sint32 ACC (RW, last_sp);     /* As last_heal, but for spell points */
  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 */
  sint64 ACC (RW, perm_exp);    /* Permanent exp */
  uint32 ACC (RW, weapontype);  /* type of weapon */
  uint32 ACC (RW, tooltype);    /* type of tool or build facility */
  sint8 ACC (RW, body_info[NUM_BODY_LOCATIONS]);        /* body info as loaded from the file */
  sint8 ACC (RW, body_used[NUM_BODY_LOCATIONS]);        /* Calculated value based on items equipped */
  faceidx ACC (RW, face);       /* Face with colors */
  living ACC (RO, stats);       /* Str, Con, Dex, etc */
  /* See the pod/objects.pod for more info about body locations */

  /* Following mostly refers to fields only used for monsters */
  uint32 ACC (RW, hide);        /* The object is hidden, not invisible */

  /* 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. */
  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
   * Note that other fields are used - these files are basically
   * only used in spells.
   */
  sint16 ACC (RW, duration);    /* How long the spell lasts */
  sint16 ACC (RW, casting_time);/* time left before spell goes off */
  uint16 ACC (RW, start_holding);
  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  */

  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 */

  char *ACC (RW, spellarg);

  /* Following are values used by any object */
  /* this objects turns into or what this object creates */
  treasurelist *ACC (RW, randomitems);  /* Items to be generated */
  flags_t flag;                 /* various flags */
#if FOR_PERL
  bool ACC (RW, flag[NUM_FLAGS]);
#endif
  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 */
  sint16 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 */
};

struct object : zero_initialised, object_copy
{
  // These variables are not changed by ->copy_to
  maptile_ptr ACC (RW, map);    /* Pointer to the map in which this object is present */

  UUID ACC (RW, uuid);          // Unique Identifier, survives saves etc.
  int ACC (RO, count);
  int ACC (RO, index);          // index into objects
  int ACC (RO, active);         // index into actives

  player_ptr ACC (RW, contr);   /* Pointer to the player which control this object */

  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 */

  //TODO: container must move into client
  object_ptr 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.
                                 */
  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
  client_container *seen_by;    // seen by which player/container currently?
  key_value *key_values;        /* Fields not explictly known by the loader. */

  bool parse_kv (object_thawer &f); // parse kv pairs, (ab-)used by archetypes, which should not exist at all
  static object *read (object_thawer &f, maptile *map = 0); // map argument due to toal design bogosity, must go.
  bool write (object_freezer &f);

  MTH static object *create ();
  object &operator =(const object &src);
  MTH void copy_to (object *dst);
  MTH object *clone (); // create + copy_to
  void do_destroy ();
  void gather_callbacks (AV *&callbacks, event_type event) const;
  MTH void destroy (bool destroy_inventory = false);

  // recursively destroy all objects in inventory, optionally dropping them to the ground instead
  MTH void destroy_inv (bool drop_to_ground = false);
  MTH object *insert (object *item); // insert into inventory
  void do_remove ();
  MTH void remove ()
  {
    if (!flag [FLAG_REMOVED])
      do_remove ();
  }

  static bool can_merge_slow (object *op1, object *op2);

  // this is often used in time-critical code, so optimise
  MTH static bool can_merge (object *op1, object *op2)
  {
    return op1->value == op2->value
        && op1->name  == op2->name
        && can_merge_slow (op1, op2);
  }

  MTH void set_owner (object *owner);
  MTH void set_speed (float speed);

  MTH void open_container (object *new_container);
  MTH void close_container ()
  {
    open_container (0);
  }

  MTH void instantiate ();

  // recalculate all stats
  MTH void update_stats ();
  MTH void roll_stats ();
  MTH void swap_stats (int a, int b);
  MTH void add_statbonus ();
  MTH void remove_statbonus ();
  MTH void drain_stat ();
  MTH void drain_specific_stat (int deplete_stats);
  MTH void change_luck (int value);

  // info must hold 256 * 3 bytes currently
  const char *debug_desc (char *info) const;
  MTH const char *debug_desc () const;
  const char *debug_desc2 () const; // another debug_desc, pure convinience function
  const char *flag_desc (char *desc, int len) const;

  int number_of () const
  {
    return nrof ? nrof : 1;
  }

  uint64 total_weight () const
  {
    return weight * number_of ();
  }

  // return the dominant material of this item, always return something
  const materialtype_t *dominant_material () const;

  // return the volume of this object in cm³
  uint64 volume () const
  {
    return total_weight ()
           * 1000
           * (type == CONTAINER ? 1000 : 1)
           / dominant_material ()->density;
  }

  MTH bool is_weapon () const { return type == ARROW || type == BOW || type == WEAPON; }
  MTH bool is_armor  () const { return type == ARMOUR  || type == SHIELD || type == HELMET
                                    || type == CLOAK   || type == BOOTS  || type == GLOVES
                                    || type == BRACERS || type == GIRDLE; }
  MTH bool is_alive  () const { return (type == PLAYER
                                        || flag [FLAG_MONSTER]
                                        || (flag [FLAG_ALIVE] && !flag [FLAG_GENERATOR] && type != DOOR))
                                       && !flag [FLAG_IS_A_TEMPLATE]; }
  MTH bool is_arrow  () const { return type == ARROW
                                       || (type == SPELL_EFFECT
                                           && (subtype == SP_BULLET || subtype == SP_MAGIC_MISSILE)); }

  MTH bool has_active_speed () const { return FABS(speed) >= MIN_ACTIVE_SPEED; }

  // temporary: wether the object can be saved in a map file
  // contr => is a player
  // head  => only save head of a multitile object
  // owner => can not reference owner yet
  MTH bool can_map_save () const { return !contr && !head && !owner && !flag [FLAG_NO_MAP_SAVE]; }

  /* This return true if object has still randomitems which
   * could be expanded.
   */
  MTH bool has_random_items () const { return randomitems && !flag [FLAG_IS_A_TEMPLATE]; }

  // returns the player that has this object in his inventory, or 0
  MTH object *in_player () const
  {
    for (object *op = env; op; op = op->env)
      if (op->type == PLAYER)
        return op;

    return 0;
  }

  // "temporary" helper function
  MTH object *head_ ()
  {
    return head ? head : this;
  }

  MTH std::string long_desc        (object *who = 0);
  MTH std::string describe_monster (object *who = 0);
  MTH std::string describe_item    (object *who = 0);
  MTH std::string describe         (object *who = 0);

  // If this object has no extra parts but should have them,
  // add them, effectively expanding heads into multipart
  // objects. This method only works on objects not inserted
  // anywhere.
  MTH void expand_tail ();

  MTH void create_treasure (treasurelist *tl, int flags = 0);

  // insert object at same map position as 'where'
  // handles both inventory and map "positions"
  MTH object *insert_at (object *where, object *originator = 0, int flags = 0);

  MTH void activate   ();
  MTH void deactivate ();
  MTH void activate_recursive   ();
  MTH void deactivate_recursive ();

  // set the givne flag on all objects in the inventory recursively
  MTH void set_flag_inv (int flag, int value = 1);

  void enter_exit (object *exit);//Perl
  MTH void enter_map (maptile *newmap, int x, int y);

  // returns the mapspace this object is in
  mapspace &ms () 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; }
  };

  MTH unsigned int random_seed () const
  {
    return (unsigned int)uuid.seq;
  }

  // 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;
  }

  /* This returns TRUE if the object is something that
   * should be displayed in the floorbox/inventory window
   */
  MTH bool client_visible () const
  {
    return !invisible && type != PLAYER;
  }

  MTH struct region *region () const;

protected:
  friend struct archetype;

  void link ();
  void unlink ();

  object ();
  ~object ();
};

typedef object_vector<object, &object::index > objectvec;
typedef object_vector<object, &object::active> activevec;

extern objectvec objects;
extern activevec actives;

#define for_all_objects(var)                    \
  for (unsigned _i = 0; _i < objects.size (); ++_i)     \
    declvar (object *, var, objects [_i])

#define for_all_actives(var)                    \
  for (unsigned _i = 0; _i < actives.size (); ++_i)     \
    declvar (object *, var, actives [_i])

typedef struct oblnk
{                               /* Used to link together several objects */
  object_ptr ob;
  struct oblnk *next;
} objectlink;

typedef struct oblinkpt
{                               /* Used to link together several object links */
  struct oblnk *link;
  long value;                   /* Used as connected value in buttons/gates */
  struct oblinkpt *next;
} oblinkpt;

/*
 * The archetype structure is a set of rules on how to generate and manipulate
 * objects which point to archetypes.
 * This probably belongs in arch.h, but there really doesn't appear to
 * be much left in the archetype - all it really is is a holder for the
 * object and pointers.  This structure should get removed, and just replaced
 * by the object structure
 */

INTERFACE_CLASS (archetype)
struct archetype : zero_initialised, attachable
{
  archetype ();
  ~archetype ();
  void gather_callbacks (AV *&callbacks, event_type event) const;

  static archetype *read (object_thawer &f);
  static archetype *get  (const char *name); // find or create
  static archetype *find (const char *name);

  void hash_add (); // add to hashtable
  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) */
  bool ACC (RW, linked);                        // linked into list of heads
  sint8 ACC (RW, tail_x), ACC (RW, tail_y);     /* Where the lower right most portion of the object is
                                                 * in comparison to the head.
                                                 */
};

/* Used by update_object to know if the object being passed is
 * being added or removed.
 */
#define UP_OBJ_INSERT   1
#define UP_OBJ_REMOVE   2
#define UP_OBJ_CHANGE   3
#define UP_OBJ_FACE     4       /* Only thing that changed was the face */

/* These are flags passed to insert_ob_in_map and 
 * insert_ob_in_ob.  Note that all flags may not be meaningful
 * for both functions.
 * Most are fairly explanatory:
 * INS_NO_MERGE: don't try to merge inserted object with ones alrady
 *    on space.
 * INS_ABOVE_FLOOR_ONLY: Put object immediatly above the floor.
 * INS_NO_WALK_ON: Don't call check_walk_on against the
 *    originator - saves cpu time if you know the inserted object
 *    is not meaningful in terms of having an effect.
 * INS_ON_TOP: Always put object on top.  Generally only needed when loading
 *     files from disk and ordering needs to be preserved. 
 * INS_BELOW_ORIGINATOR: Insert new object immediately below originator -
 *     Use for treasure chests so the new object is the highest thing
 *     beneath the player, but not actually above it.  Note - the
 *     map and x,y coordinates for the object to be inserted must
 *     match the originator.
 * INS_MAP_LOAD: disable lots of checkings done at insertion to
 *     speed up map loading process, as we assume the ordering in
 *     loaded map is correct.
 *
 * Note that INS_BELOW_ORIGINATOR, INS_ON_TOP, INS_ABOVE_FLOOR_ONLY
 * are mutually exclusive.  The behaviour for passing more than one
 * should be considered undefined - while you may notice what happens
 * right now if you pass more than one, that could very well change
 * in future revisions of the code.
 */
#define INS_NO_MERGE            0x0001
#define INS_ABOVE_FLOOR_ONLY    0x0002
#define INS_NO_WALK_ON          0x0004
#define INS_ON_TOP              0x0008
#define INS_BELOW_ORIGINATOR    0x0010
#define INS_MAP_LOAD            0x0020

#define ARCH_SINGULARITY        "singularity"
#define ARCH_DETECT_MAGIC       "detect_magic"
#define ARCH_DEPLETION          "depletion"
#define ARCH_SYMPTOM            "symptom"

#endif

Revision:	1.112
Committed:	Mon Apr 30 04:25:30 2007 UTC (17 years, 1 month ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.111:	+1 -1 lines
Log Message:	This is the first rough cut of the skill use system (use the STABLE tag). Details will likely change, and combat skills do not work very well, but it works quite well. Players no longer have a shoottype or range slots, instead, each player has these members: combat_skill/combat_ob the currently selected skill (and weapon) for direct attacks. ranged_skill/ranged_ob the currently selected ranged skill (and bow/spell/item) golem the currently-controlled golem, if any.