ScriptObj.C

Go to the documentation of this file.

/** @file ScriptObj.C
    @see ScriptObj.H

    $Id: ScriptObj.C 5279 2007-06-23 02:49:08Z mburo $
    $Source$
*/

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

#include "ScriptObj.H"
#include "Blueprints.H"
#include "PlayerInfo.H"
#include "Script.H"
#include "ByteData.H"

using namespace std;

#define PARANOID

set<ScriptObj*> ScriptObj::ptr_list;

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

IdObjMap ScriptObj::id2obj_map;
ObjIdMap ScriptObj::obj2id_map;
IdFactory ScriptObj::idf(100000);

Vector<ScriptObj*> ScriptObj::dead_objs;
list<ScriptObj*> ScriptObj::destroyed_objs;

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

ScriptObj::BasePtr::BasePtr(ScriptObj *s)
{
  check_ptr(s);

  p = s;
  if (p == 0) {
    id = 0;
    return;
  }
  FIND (ScriptObj::obj2id_map, it, p);
  if (it == obj2id_map.end()) {
    ERR("bad pointer");
  }
  id = it->second;
}

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

ScriptObj::BasePtr::BasePtr(const ScriptObj::BasePtr &ptr)
{
  p = ptr.p;
  id = ptr.id;
  check_ptr(p);
}

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

void ScriptObj::BasePtr::reset()
{
  p = 0;
  id = 0;
}

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

ScriptObj::Ptr::Ptr(ScriptObj *s) : BasePtr(s)
{
  if (!p) return;
  p->hard_refs.insert(this);
  p->add_ref();
}

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

ScriptObj::Ptr::Ptr(const ScriptObj::Ptr &ptr) : BasePtr(ptr)
{
  if (!p) return;
  p->hard_refs.insert(this);
  p->add_ref();
}

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

ScriptObj::Ptr& ScriptObj::Ptr::operator=(const ScriptObj::Ptr &ptr)
{
  check_ptr(p);
  if (p) {
    p->hard_refs.erase(this);
    p->del_ref();
  }
  
  p = ptr.p;
  id = ptr.id;

  check_ptr(p);
  if (p) {
    p->hard_refs.insert(this);
    p->add_ref();
  }
  return *this;
}

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

ScriptObj::Ptr::~Ptr()
{
  check_ptr(p);
  if (!p) return;
  p->hard_refs.erase(this);
  p->del_ref();
}

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

void ScriptObj::Ptr::save(ostream &os) const
{
  ObjId id = ScriptObj::obj2id_map[p];
  OS_WRITE(id);
}

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

void ScriptObj::Ptr::load(istream &is)
{
  ObjId id;
  IS_READ(id);
  p = ScriptObj::id2obj_map[id];
}

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

ScriptObj::WPtr::WPtr(ScriptObj *s) : BasePtr(s)
{
  if (!p) return;
  p->soft_refs.insert(this);
}

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

ScriptObj::WPtr::WPtr(const ScriptObj::WPtr &ptr) : BasePtr(ptr)
{
  if (!p) return;
  p->soft_refs.insert(this);
}

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

ScriptObj::WPtr& ScriptObj::WPtr::operator=(const ScriptObj::WPtr &ptr)
{
  check_ptr(p);
  if (p) {
    p->soft_refs.erase(this);
  }
  
  p = ptr.p;
  id = ptr.id;

  check_ptr(p);
  if (p) {
    p->soft_refs.insert(this);
  }
  return *this;
}

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

ScriptObj::WPtr::~WPtr()
{
  if (!p) return;
  p->soft_refs.erase(this);
}

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

void ScriptObj::WPtr::save(ostream &os) const
{
  ObjId id = ScriptObj::obj2id_map[p];
  OS_WRITE(id);
}

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

void ScriptObj::WPtr::load(istream &is)
{
  ObjId id;
  IS_READ(id);
  p = ScriptObj::id2obj_map[id];
}

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

ScriptObj::ScriptObj()
{
  num_refs = 0;
  dead = false;
  enabled = true;
  parent = this;
#ifdef PARANOID
  //The relevant types cannot be registered due to some unknown reason: FIND(ptr_list, i, this);
  set<ScriptObj*>::iterator i = ptr_list.find(this);
  if (i != ptr_list.end()) ERR("already in set?");
  ptr_list.insert(this);
#endif

  id = idf.next();
  assert(id2obj_map[id] == 0);
  id2obj_map[id] = this;
  obj2id_map[this] = id;
}

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

ScriptObj::~ScriptObj()
{
  FORALL (soft_refs, it) {
    (*it)->reset();
  }
  FORALL (hard_refs, it) {
    (*it)->reset();
  }

  idf.free(id);
  id2obj_map.erase(id2obj_map.find(id));
  obj2id_map.erase(obj2id_map.find(this));
#ifdef PARANOID
  //The relevant types cannot be registered due to some unknown reason: FIND(ptr_list, i, this);
  set<ScriptObj*>::iterator it = ptr_list.find(this);
  if (it != ptr_list.end()) ptr_list.erase(it);
#endif
}

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

void ScriptObj::save(ostream &os) const
{
  string s;
  ERR("need PlayerInfo data here");
  gen_diff(true, true, s, 0);
  os << s;
}

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

void ScriptObj::load(istream &is)
{
  string s;
  is >> s;
  ByteStream bs(s);
  ERR ("need PlayerInfo data here");
  apply_diff(bs, 0);
}

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

/** Intended for use in saving/loading the game state in combination with set_ids. */

void ScriptObj::get_ids(Vector<ScriptObj*> &objs, Vector<ObjId> &ids)
{
  ids.clear();
  objs.clear();

  FORALL (id2obj_map, it) {
    ids.push_back(it->first);
    objs.push_back(it->second);
  }
}

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

/** Intended for use in saving/loading the game state in combination with get_ids. */

void ScriptObj::set_ids(const Vector<ScriptObj*> &objs, const Vector<ObjId> &ids)
{
  if (objs.size() != ids.size()) ERR("size mismatch");
  id2obj_map.clear();
  obj2id_map.clear();
  idf.reserve(ids);
  FORU (i, objs.size()) {
    id2obj_map[ids[i]] = objs[i];
    obj2id_map[objs[i]] = ids[i];
  }
}

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

ObjId ScriptObj::get_obj_id(ScriptObj *s)
{
  FIND(obj2id_map, it, s);
  if (it == obj2id_map.end()) return 0;
  return it->second;
}

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

void ScriptObj::kill()
{
  if (!dead) dead_objs.push_back(this);
  dead = true;
}

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

/** Call script destructors for dead objects.
    Delete them if they're not being referenced.
    NOTE: it's possible for new objects to be added to dead_objs when the destructors are called.
*/

void ScriptObj::collect_dead(std::set<ScriptObj*> &dead)
{
  dead.clear();
  // note: if new objects are added to dead_objs when the destructors are called
  //       then the iterator will be invalidated, so do it this way.
  FORU_DYN (i, dead_objs.size()) {
    ScriptObj *g = dead_objs[i];
    dead.insert(g);
    g->destruct();
    if (g->get_refs() == 0) {
      delete g;
    } else {
      destroyed_objs.push_back(g);
    }
  }
  dead_objs.clear();
}

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

/** Delete dead objects that aren't being referenced. */

void ScriptObj::collect_destroyed()
{
  list<ScriptObj*>::iterator it;
  for (it = destroyed_objs.begin(); it != destroyed_objs.end();) {
    if ((*it)->get_refs() == 0) {
      delete *it;
      it = destroyed_objs.erase(it);
      continue;
    }
    ++it;
  }
}

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

void ScriptObj::check_ptr(ScriptObj *ptr) {
#ifdef PARANOID
  if (ptr == 0) return;
  if (ptr_list.find(ptr) != ptr_list.end()) return;
  cerr << ptr << endl;
  volatile int foo = 0;
  foo /= foo;
  ERR("no such scriptobj");
#endif
}

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

bool ScriptObj::has_attr(const string &a) const {
  return get_val_ptr(a) != 0;
}

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

stype ScriptObj::get_val(const string &a) const {
  const stype *p = get_val_ptr(a);
  if (p == 0) {
    cerr << "object type = " << bp_name() << endl;
    ERR2("unknown attribute ", a.c_str());
    return stype();
  }
  return *p;
}

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

void ScriptObj::set_val(const string &a, stype v, bool warn) {
  stype *p =  get_val_ptr(a);
  if (p == 0) {
    if (warn) ERR2("unknown attribute", a.c_str());
    return;
  }
  *p = v;
}

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

sint4 ScriptObj::get_int(const string &a) const {
  const stype *p = get_val_ptr(a);
  if (!p) ERR2("unknown attribute", a.c_str());
  return p->to_int();
}

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

sint4 ScriptObj::get_int_prev(const string &a) const {
  stype p = get_val_prev(a);
  return p.to_int();
}

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

sintptr* ScriptObj::get_int_ptr(const string &a) {
  stype *p = get_val_ptr(a);
  if (!p) return 0;
  if (p->type == stype::NONE) return 0;
  if (p->type != stype::INT) ERR2("not integer", a.c_str());
  return &p->val.i;
}

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

const sintptr* ScriptObj::get_int_ptr(const string &a) const {
  const stype *p = get_val_ptr(a);
  if (!p) return 0;
  if (p->type != stype::INT) ERR2("not integer", a.c_str());
  return &p->val.i;
}

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

void ScriptObj::set_int(const string &a, sint4 v, bool warn) {
  sintptr *p = get_int_ptr(a);
  if (!p) {
    if (warn) ERR2("unknown attribute", a.c_str());
    return;
  }
  *p = v;
}

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