GameObj.H

Go to the documentation of this file.

#ifndef GameObj_H
#define GameObj_H

/** @file GameObj.H
    The objects that populate the world.
    $Id: GameObj.H 6869 2008-04-07 05:32:39Z furtak $
    $Source$
*/

// This is an ORTS file (c) Michael Buro, licensed under the GPL

#include "Global.H"
#include "ScriptObj.H"
#include "Object.H"
#include "Action.H"

class GameObjBlueprint;
class PlayerInfo;

//===================================================================

/** Objects that interact with the world. */

class GameObj : public ScriptObj, public Object {

public:
  class BasePtr;
  class WPtr;
  class Ptr;

  ServerObjData sod;    ///< Pointers to certain often-accessed variables.  Avoids string lookup.

  ServerMotionData smd; ///< Properties used for object motion/collision.
  Action cur_action;    ///< The current action about to be taken and parameters.
  sint4 enable_count;   ///< 1 - # of disabled parent objects.

  uint4 dir_dmg;        ///< Bit vector for whether damage was taken from each direction range.
  uint4 dir_dmg2;       ///< Same as dir_dmg, but for damage from the air.
  Vector<uint4> dir_damage; ///< [GameConst::DAMAGE_N+1] Amount of damage received from each dir.
  uint2 dir_max_damage; ///< The direction (1...DAMAGE_N) that the most damage came from.

  typedef std::map<std::string, SimpleActions::saction*> CommandMap;
  CommandMap last_command_map; ///< pending actions
  typedef Vector<SimpleActions::saction**> Command;
  Command last_command; ///< Points to the pointer in last_command_map.  Includes component actions.

  GameObj(GameObjBlueprint &bp, GameObj *parent = 0);
  GameObj(const GameObj &gob) : ScriptObj(gob), Object(gob) { ERR("foo"); }
  virtual ~GameObj();

  void update_sod();
  void update_points() const;

  // If enable_count <= 0 then the client can't send actions for the object.
  virtual void enable();
  virtual void disable();
  virtual sint4 get_refs() const;
  virtual bool is_enabled() { return enable_count > 0; }

  void print(std::ostream &os = std::cout) const;
  void notify_attack(GameObj *targ, sint4 damage);

  virtual std::string bp_name() const;
  virtual uint4 code() const;
  virtual void attr_names(Vector<std::string> &) const;
  virtual bool attr_changed(const std::string &a) const;

  virtual stype get_val_prev(const std::string &a) const;
  virtual stype* get_val_ptr(const std::string &a);
  virtual const stype* get_val_ptr(const std::string &a) const;
  virtual void  set_val(const std::string &a, stype v, bool warn=true);

  virtual void gen_diff(bool first, bool allied, std::string &s, PlayerInfo *pi) const;
  virtual void gen_comp_diff(bool first, bool allied, std::string &s, PlayerInfo *pi) const;
  virtual bool apply_diff(ByteStream &s, PlayerInfo *pi);
  virtual bool apply_comp_diff(bool allied, ByteStream &s, bool first, PlayerInfo *pi);
  virtual void copy_to_prev();
  virtual void reset_frame_data(); // reset_attr_vals

  virtual void action_names(Vector<std::string> &names) const;

  virtual void queue_action(sint4 frame_sent); // don't call in client user code
  virtual std::string write_action(ObjId my_id) const;

  virtual ObjAction* action(const std::string &name) const;
  virtual ObjAction* action(sint4 id) const;
  virtual sint4 action_id(const std::string &name) const;
  virtual bool action_enabled(sint4 id)                const;
  virtual bool action_enabled(const std::string &name) const;
  virtual bool action_hidden(sint4 id)                 const;
  virtual bool action_hidden(const std::string &name)  const;

  virtual void component_names(Vector<std::string> &names) const;
  virtual ScriptObj* component(const std::string &name) const;
  virtual ScriptObj* action_component(sint4 id) const { return action2component[id]; }

  virtual void construct();
  virtual void destruct();

  virtual GameObj* get_GameObj() { return this; }

  friend class GameObjFactory;
  friend class ScriptParser;


  // Client data/functions

  // 0 if error, client_action_id > 0 if OK
  virtual uint4 set_action(const std::string &name, const Vector<sint4> &params, sint4 priority=1);
  virtual uint4 set_action(sint4 id, const Vector<sint4> &params, sint4 priority=1);
  virtual uint4 set_action(const std::string &name, const Vector<stype> &params, sint4 priority=1);
  virtual uint4 set_action(sint4 id, const Vector<stype> &params, sint4 priority=1);

  virtual bool action_already_set() const;
  virtual void clear_action();
  
  struct ActInfo
  {
    sint4 frame_sent;       // view_frame action was sent to server
    GameObj *obj;           // actor
    uint4 client_action_id; // for easy action identification in client
    uint4 error_code;       // 0:OK, >0:ERROR, fixme: to be sent from server

    ActInfo(sint4 frame_sent_=0, uint4 client_action_id_=0, GameObj *obj_=0, uint4 error_code_=0)
      : frame_sent(frame_sent_),
    obj(obj_),
    client_action_id(client_action_id_),
    error_code(error_code_)
    { }
  };

  // Pending actions
  //
  // Updated in GameStateModule (send_actions, recv_view). So,
  // technically shouldn't be here because Game doesn't do anything
  // with it. But: having it here avoids maintaining a gameobj->queue map.
  std::list<ActInfo> pending_actions; ///< Actions that have been sent to the server and are awaiting response.
  
  // Object virtual functions
  
  Object::Shape get_shape() const;
  sint4 get_max_speed() const;
  sint4 get_radius() const;
  Object::ZCat get_zcat(ZCat *prev) const;  
  sint4 get_speed(sint4 *prev) const;
  bool get_moving(bool *prev) const ; 
  void get_center(sint4 &x, sint4 &y, sint4 *px=0, sint4 *py=0) const;
  void get_p1(sint4 &x, sint4 &y, sint4 *px=0, sint4 *py=0) const; // upper left corner
  void get_p2(sint4 &x, sint4 &y, sint4 *px=0, sint4 *py=0) const; // lower right corner
  bool is_pending_action(void) const;
  real8 distance_to(const Object &other) const;

  // Auxiliary "shortcut" methods
  const GameObjBlueprint* get_bp() const {
    return blueprint;
  }
  const stype* get_val_ptr(sint4 index) const {
    return &attr_vals[index];
  }
  sint4 component_index(const std::string &name) const {
    FIND (name2comp, it, name);
    if (it != name2comp.end()) return it->second;
    return -1;
  }
  const ScriptObj* component(sint4 index) const {
    return components[index];
  }

protected:

  GameObj() { blueprint = 0; }

  void init_sod();
  void delete_sod();

  sint4 num_const, num_stable, num_variable;
  Vector<stype> attr_vals;
  Vector<stype> prev_attr_vals;
  GameObjBlueprint *blueprint;
  Vector<GameObj*> action2component; ///< The sub-object that each action belongs to.
  /// Pointers to enable_count for the component that owns each action (used by the root).

  Vector<sint4*> action_enabled_list;
  typedef std::map<std::string, sint4> Name2CompInd;
  Name2CompInd name2comp;        ///< Maps component name to component index.
  Vector<ScriptObj*> components; ///< Sub-objects.
  void inc_enable_count();
  void dec_enable_count();

  // helpers

private:
  
  static uint4 next_client_action_id();
};

//-------------------------------------------------------------------

/** A 'weak' pointer.
    Not strong enough to prevent its target from being deleted.
*/

class GameObj::WPtr : public ScriptObj::WPtr
{
public:
  inline GameObj* operator->() const { return (GameObj*)p; }
  inline GameObj& operator*() const { if (!p) { std::cout << "DANGER" << std::endl; } return *(GameObj*)p; }
  inline operator GameObj* () const { return (GameObj*)p; }

  WPtr() {}
  WPtr(GameObj *s);
  WPtr(const WPtr &ptr);
  //  ~WPtr() {}
};

//-------------------------------------------------------------------

/** A 'strong' pointer.
    The object is maintained as long as at least one strong pointer
    is referencing it.
*/

class GameObj::Ptr : public ScriptObj::Ptr
{
public:
  inline GameObj* operator->() const { return (GameObj*)p; }
  inline GameObj& operator*() const { if (!p) { std::cout << "DANGER" << std::endl; } return *(GameObj*)p; }
  inline operator GameObj* () const { return (GameObj*)p; }

  Ptr() {}
  Ptr(GameObj *g);
  Ptr(const Ptr &ptr);
  //  ~Ptr() {}
  
  inline operator GameObj::WPtr () const { return GameObj::WPtr((GameObj*)p); }
};

//===================================================================

REGISTER_TYPEOF(56, std::set<GameObj*>::iterator);
REGISTER_TYPEOF(57, std::set<GameObj*>::const_iterator);
REGISTER_TYPEOF(58, Vector<GameObj*>::iterator);
REGISTER_TYPEOF(59, Vector<GameObj*>::const_iterator);
REGISTER_TYPEOF(60, GameObj::CommandMap::iterator);
REGISTER_TYPEOF(61, GameObj::CommandMap::const_iterator);
REGISTER_TYPEOF(108, std::list<GameObj::ActInfo>::iterator);
REGISTER_TYPEOF(109, std::list<GameObj::ActInfo>::const_iterator);

//===================================================================

#endif