/*
 *	server/zone/objects/scene/SceneObject.cpp generated by engine3 IDL compiler 0.60
 */

#include "SceneObject.h"

#include "server/zone/managers/objectcontroller/ObjectController.h"

#include "server/zone/ZoneProcessServer.h"

#include "server/zone/ZoneClientSession.h"

#include "server/zone/Zone.h"

#include "server/zone/ZoneServer.h"

#include "server/zone/objects/building/BuildingObject.h"

#include "server/zone/packets/object/ObjectMenuResponse.h"

#include "server/zone/objects/creature/CreatureObject.h"

#include "server/zone/packets/scene/AttributeListMessage.h"

#include "server/zone/templates/SharedObjectTemplate.h"

#include "server/zone/objects/area/ActiveArea.h"

#include "server/zone/objects/region/CityRegion.h"

#include "server/zone/objects/creature/CreatureObject.h"

/*
 *	SceneObjectStub
 */

enum {RPC_FINALIZE__ = 6,RPC_INITIALIZEPRIVATEDATA__,RPC_CREATECOMPONENTS__,RPC_CREATECONTAINERCOMPONENT__,RPC_INITIALIZETRANSIENTMEMBERS__,RPC_NOTIFYLOADFROMDATABASE__,RPC_INFO__STRING_BOOL_,RPC_ERROR__STRING_,RPC_INRANGEOBJECTS__INT_FLOAT_,RPC_ISINRANGE__SCENEOBJECT_FLOAT_,RPC_TRANSFEROBJECT__SCENEOBJECT_INT_BOOL_,RPC_REMOVEOBJECT__SCENEOBJECT_SCENEOBJECT_BOOL_,RPC_DESTROYOBJECTFROMWORLD__BOOL_,RPC_CANADDOBJECT__SCENEOBJECT_INT_STRING_,RPC_NOTIFYOBJECTINSERTEDTOCHILD__SCENEOBJECT_SCENEOBJECT_SCENEOBJECT_,RPC_NOTIFYOBJECTREMOVEDFROMCHILD__SCENEOBJECT_SCENEOBJECT_,RPC_SYNCHRONIZEDUILISTEN__SCENEOBJECT_INT_,RPC_SYNCHRONIZEDUISTOPLISTEN__SCENEOBJECT_INT_,RPC_UPDATETODATABASE__,RPC_UPDATETODATABASEWITHOUTCHILDREN__,RPC_UPDATETODATABASEALLOBJECTS__BOOL_,RPC_DESTROYPLAYERCREATUREFROMDATABASE__BOOL_,RPC_DESTROYOBJECTFROMDATABASE__BOOL_,RPC_CANBEDESTROYED__CREATUREOBJECT_,RPC_LINK__LONG_INT_,RPC_SENDTO__SCENEOBJECT_BOOL_,RPC_SENDWITHOUTPARENTTO__SCENEOBJECT_,RPC_SENDWITHOUTCONTAINEROBJECTSTO__SCENEOBJECT_,RPC_SENDDESTROYTO__SCENEOBJECT_,RPC_SENDBASELINESTO__SCENEOBJECT_,RPC_SENDCONTAINEROBJECTSTO__SCENEOBJECT_,RPC_SENDSLOTTEDOBJECTSTO__SCENEOBJECT_,RPC_SENDTOOWNER__BOOL_,RPC_SENDATTRIBUTELISTTO__CREATUREOBJECT_,RPC_SETCUSTOMOBJECTNAME__UNICODESTRING_BOOL_,RPC_OPENCONTAINERTO__CREATUREOBJECT_,RPC_CLOSECONTAINERTO__CREATUREOBJECT_BOOL_,RPC_NOTIFYINSERTTOZONE__ZONE_,RPC_SWITCHZONE__STRING_FLOAT_FLOAT_FLOAT_LONG_,RPC_TELEPORT__FLOAT_FLOAT_FLOAT_LONG_,RPC_UPDATEDIRECTION__FLOAT_FLOAT_FLOAT_FLOAT_,RPC_UPDATEDIRECTION__FLOAT_,RPC_NOTIFYREMOVEFROMZONE__,RPC_UPDATEZONE__BOOL_BOOL_,RPC_UPDATEZONEWITHPARENT__SCENEOBJECT_BOOL_BOOL_,RPC_BROADCASTMESSAGE__BASEPACKET_BOOL_BOOL_,RPC_BROADCASTMESSAGEPRIVATE__BASEPACKET_SCENEOBJECT_BOOL_,RPC_BROADCASTOBJECT__SCENEOBJECT_BOOL_,RPC_BROADCASTOBJECTPRIVATE__SCENEOBJECT_SCENEOBJECT_,RPC_BROADCASTDESTROY__SCENEOBJECT_BOOL_,RPC_BROADCASTDESTROYPRIVATE__SCENEOBJECT_SCENEOBJECT_,RPC_SENDMESSAGE__BASEPACKET_,RPC_COMPARETO__SCENEOBJECT_,RPC_GETPARENTID__,RPC_CONTAINSPENDINGTASK__STRING_,RPC_SHOWFLYTEXT__STRING_STRING_BYTE_BYTE_BYTE_,RPC_GETCONTAINEDOBJECTSRECURSIVE__,RPC_GETACTIVESESSION__INT_,RPC_ADDACTIVESESSION__INT_FACADE_,RPC_CONTAINSACTIVESESSION__INT_,RPC_DROPACTIVESESSION__INT_,RPC_GETACTIVESESSIONSCOUNT__,RPC_HANDLEOBJECTMENUSELECT__CREATUREOBJECT_BYTE_,RPC_GETDISTANCETO__SCENEOBJECT_,RPC_UPDATEVEHICLEPOSITION__BOOL_,RPC_NOTIFYOBJECTINSERTED__SCENEOBJECT_,RPC_NOTIFYOBJECTREMOVED__SCENEOBJECT_,RPC_ADDACTIVEAREA__ACTIVEAREA_,RPC_DROPACTIVEAREA__ACTIVEAREA_,RPC_HASACTIVEAREA__ACTIVEAREA_,RPC_HASACTIVEAREA__LONG_,RPC_GETACTIVEAREASSIZE__,RPC_GETACTIVEREGION__,RPC_GETZONE__,RPC_GETLOCALZONE__,RPC_GETOBJECTID__,RPC_GETWORLDPOSITIONX__,RPC_GETWORLDPOSITIONY__,RPC_GETWORLDPOSITIONZ__,RPC_GETDIRECTIONX__,RPC_GETDIRECTIONZ__,RPC_GETDIRECTIONY__,RPC_GETDIRECTIONW__,RPC_GETCLIENTOBJECTCRC__,RPC_GETSERVEROBJECTCRC__,RPC_ISWAYPOINTOBJECT__,RPC_GETOBJECTNAMESTRINGIDFILE__,RPC_GETOBJECTNAMESTRINGIDNAME__,RPC_SETDETAILEDDESCRIPTION__STRING_,RPC_GETARRANGEMENTDESCRIPTORSIZE__,RPC_GETARRANGEMENTDESCRIPTOR__INT_,RPC_GETSLOTDESCRIPTOR__INT_,RPC_HASSLOTDESCRIPTOR__STRING_,RPC_HASARRANGEMENTDESCRIPTOR__STRING_,RPC_GETSLOTTEDOBJECT__STRING_,RPC_GETSLOTDESCRIPTORSIZE__,RPC_GETSLOTTEDOBJECT__INT_,RPC_DROPSLOTTEDOBJECT__STRING_,RPC_REMOVESLOTTEDOBJECT__INT_,RPC_GETCONTAINEROBJECTSSIZE__,RPC_GETSLOTTEDOBJECTSSIZE__,RPC_HASFULLCONTAINEROBJECTS__,RPC_GETCONTAINERVOLUMELIMIT__,RPC_GETCONTAINEROBJECT__INT_,RPC_HASOBJECTINCONTAINER__LONG_,RPC_HASOBJECTINSLOTTEDCONTAINER__SCENEOBJECT_,RPC_GETCONTAINEROBJECT__LONG_,RPC_REMOVEALLCONTAINEROBJECTS__,RPC_PUTINCONTAINER__SCENEOBJECT_LONG_,RPC_REMOVEFROMCONTAINEROBJECTS__INT_,RPC_SETCONTAINERVOLUMELIMIT__INT_,RPC_SETCONTAINERTYPE__INT_,RPC_GETCONTAINERTYPE__,RPC_GETCLIENT__,RPC_GETGAMEOBJECTTYPE__,RPC_GETCLIENTGAMEOBJECTTYPE__,RPC_GETCONTAINMENTTYPE__,RPC_GETDIRECTIONANGLE__,RPC_GETSPECIALDIRECTIONANGLE__,RPC_ROTATE__INT_,RPC_FACEOBJECT__SCENEOBJECT_,RPC_NOTIFYSELFPOSITIONUPDATE__,RPC_NOTIFYPOSITIONUPDATE__QUADTREEENTRY_,RPC_NOTIFYCLOSECONTAINER__CREATUREOBJECT_,RPC_GETMOVEMENTCOUNTER__,RPC_GETPARENT__,RPC_GETZONESERVER__,RPC_GETROOTPARENT__,RPC_GETPARENTRECURSIVELY__INT_,RPC_ISASUBCHILDOF__SCENEOBJECT_,RPC_GETCUSTOMOBJECTNAME__,RPC_GETLOGGINGNAME__,RPC_ISPLAYERCREATURE__,RPC_ISNOTRADE__,RPC_ISCONTAINERFULL__,RPC_ISSHUTTLEINSTALLATION__,RPC_ISPLAYEROBJECT__,RPC_ISACTIVEAREA__,RPC_ISREGION__,RPC_ISCREATUREOBJECT__,RPC_ISAIAGENT__,RPC_ISSHIPOBJECT__,RPC_ISVEHICLEOBJECT__,RPC_ISBUILDINGOBJECT__,RPC_ISCLONINGBUILDINGOBJECT__,RPC_ISGARAGE__,RPC_ISWEAPONOBJECT__,RPC_ISWEARABLEOBJECT__,RPC_ISARMOROBJECT__,RPC_ISROBEOBJECT__,RPC_ISLIGHTSABERCRYSTALOBJECT__,RPC_ISFIREWORKOBJECT__,RPC_ISPSGARMOROBJECT__,RPC_ISCELLOBJECT__,RPC_ISTANGIBLEOBJECT__,RPC_ISRESOURCECONTAINER__,RPC_ISRESOURCESPAWN__,RPC_ISCOMPONENT__,RPC_ISINTANGIBLEOBJECT__,RPC_ISINSTRUMENT__,RPC_ISBAZAARTERMINAL__,RPC_ISLIVESAMPLE__,RPC_ISINSTALLATIONOBJECT__,RPC_ISHARVESTEROBJECT__,RPC_ISGENERATOROBJECT__,RPC_ISCITYTERMINAL__,RPC_ISCITYVOTETERMINAL__,RPC_ISFACTORY__,RPC_ISFACTORYCRATE__,RPC_ISFISHINGPOLEOBJECT__,RPC_ISDEEDOBJECT__,RPC_ISVEHICLEDEEDOBJECT__,RPC_ISBUILDINGDEED__,RPC_ISSIGNOBJECT__,RPC_ISINSTALLATIONDEED__,RPC_ISCRAFTINGTOOL__,RPC_ISCRAFTINGSTATION__,RPC_ISMANUFACTURESCHEMATIC__,RPC_ISSTRUCTUREOBJECT__,RPC_ISAUCTIONOBJECT__,RPC_ISFISHINGBAIT__,RPC_ISTRAPOBJECT__,RPC_ISREPAIRTOOL__,RPC_ISCAMOKIT__,RPC_ISATTACHMENT__,RPC_ISDICEOBJECT__,RPC_ISCREATUREHABITAT__,RPC_ISCAMPKIT__,RPC_ISCAMPSTRUCTURE__,RPC_SETCONTAINERDEFAULTALLOWPERMISSION__SHORT_,RPC_CLEARCONTAINERDEFAULTALLOWPERMISSION__SHORT_,RPC_SETCONTAINERDEFAULTDENYPERMISSION__SHORT_,RPC_CLEARCONTAINERDEFAULTDENYPERMISSION__SHORT_,RPC_SETCONTAINERINHERITPERMISSIONSFROMPARENT__BOOL_,RPC_SETCONTAINEROWNERID__LONG_,RPC_SETCONTAINERALLOWPERMISSION__STRING_SHORT_,RPC_SETCONTAINERDENYPERMISSION__STRING_SHORT_,RPC_SETGAMEOBJECTTYPE__INT_,RPC_SETCLIENTOBJECTCRC__INT_,RPC_SETSERVEROBJECTCRC__INT_,RPC_SETZONE__ZONE_,RPC_SETDIRECTION__FLOAT_FLOAT_FLOAT_FLOAT_,RPC_SETDIRECTION__FLOAT_,RPC_SETMOVEMENTCOUNTER__INT_,RPC_INCREMENTMOVEMENTCOUNTER__,RPC_SETCONTAINMENTTYPE__INT_,RPC_SETLOGGINGNAME__STRING_,RPC_SETCLIENTOBJECT__BOOL_,RPC_GETPLANETCRC__,RPC_ISSTATICOBJECT__,RPC_ISCONTAINEROBJECT__,RPC_ISTERMINAL__,RPC_ISGROUPOBJECT__,RPC_ISGUILDOBJECT__,RPC_ISCONTROLDEVICE__,RPC_ISMISSIONTERMINAL__,RPC_ISMISSIONOBJECT__,RPC_ISACTOROBJECT__,RPC_GETPLANETMAPCATEGORYCRC__,RPC_GETPLANETMAPSUBCATEGORYCRC__,RPC_CONTAINSCHILDOBJECT__SCENEOBJECT_,RPC_CREATECHILDOBJECTS__,RPC_INITIALIZECHILDOBJECT__SCENEOBJECT_,RPC_ISINWATER__,RPC_GETDISPLAYEDNAME__,RPC_DOSENDTOCLIENT__,RPC_SETSENDTOCLIENT__BOOL_};

SceneObject::SceneObject() : QuadTreeEntry(DummyConstructorParameter::instance()) {
	SceneObjectImplementation* _implementation = new SceneObjectImplementation();
	_impl = _implementation;
	_impl->_setStub(this);
	_setClassName("SceneObject");
}

SceneObject::SceneObject(DummyConstructorParameter* param) : QuadTreeEntry(param) {
	_setClassName("SceneObject");
}

SceneObject::~SceneObject() {
}



void SceneObject::initializePrivateData() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_INITIALIZEPRIVATEDATA__);

		method.executeWithVoidReturn();
	} else
		_implementation->initializePrivateData();
}

void SceneObject::loadTemplateData(SharedObjectTemplate* templateData) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->loadTemplateData(templateData);
}

void SceneObject::createComponents() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CREATECOMPONENTS__);

		method.executeWithVoidReturn();
	} else
		_implementation->createComponents();
}

void SceneObject::createContainerComponent() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CREATECONTAINERCOMPONENT__);

		method.executeWithVoidReturn();
	} else
		_implementation->createContainerComponent();
}

void SceneObject::initializeTransientMembers() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_INITIALIZETRANSIENTMEMBERS__);

		method.executeWithVoidReturn();
	} else
		_implementation->initializeTransientMembers();
}

void SceneObject::notifyLoadFromDatabase() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYLOADFROMDATABASE__);

		method.executeWithVoidReturn();
	} else
		_implementation->notifyLoadFromDatabase();
}

void SceneObject::info(const String& msg, bool forced) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_INFO__STRING_BOOL_);
		method.addAsciiParameter(msg);
		method.addBooleanParameter(forced);

		method.executeWithVoidReturn();
	} else
		_implementation->info(msg, forced);
}

void SceneObject::error(const String& msg) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ERROR__STRING_);
		method.addAsciiParameter(msg);

		method.executeWithVoidReturn();
	} else
		_implementation->error(msg);
}

int SceneObject::inRangeObjects(unsigned int gameObjectType, float range) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_INRANGEOBJECTS__INT_FLOAT_);
		method.addUnsignedIntParameter(gameObjectType);
		method.addFloatParameter(range);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->inRangeObjects(gameObjectType, range);
}

bool SceneObject::isInRange(SceneObject* obj, float range) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISINRANGE__SCENEOBJECT_FLOAT_);
		method.addObjectParameter(obj);
		method.addFloatParameter(range);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isInRange(obj, range);
}

bool SceneObject::transferObject(SceneObject* object, int containmentType, bool notifyClient) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_TRANSFEROBJECT__SCENEOBJECT_INT_BOOL_);
		method.addObjectParameter(object);
		method.addSignedIntParameter(containmentType);
		method.addBooleanParameter(notifyClient);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->transferObject(object, containmentType, notifyClient);
}

bool SceneObject::removeObject(SceneObject* object, SceneObject* destination, bool notifyClient) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_REMOVEOBJECT__SCENEOBJECT_SCENEOBJECT_BOOL_);
		method.addObjectParameter(object);
		method.addObjectParameter(destination);
		method.addBooleanParameter(notifyClient);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->removeObject(object, destination, notifyClient);
}

void SceneObject::destroyObjectFromWorld(bool sendSelfDestroy) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_DESTROYOBJECTFROMWORLD__BOOL_);
		method.addBooleanParameter(sendSelfDestroy);

		method.executeWithVoidReturn();
	} else
		_implementation->destroyObjectFromWorld(sendSelfDestroy);
}

int SceneObject::canAddObject(SceneObject* object, int containmentType, String& errorDescription) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CANADDOBJECT__SCENEOBJECT_INT_STRING_);
		method.addObjectParameter(object);
		method.addSignedIntParameter(containmentType);
		method.addAsciiParameter(errorDescription);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->canAddObject(object, containmentType, errorDescription);
}

int SceneObject::notifyObjectInsertedToChild(SceneObject* object, SceneObject* child, SceneObject* oldParent) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYOBJECTINSERTEDTOCHILD__SCENEOBJECT_SCENEOBJECT_SCENEOBJECT_);
		method.addObjectParameter(object);
		method.addObjectParameter(child);
		method.addObjectParameter(oldParent);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->notifyObjectInsertedToChild(object, child, oldParent);
}

int SceneObject::notifyObjectRemovedFromChild(SceneObject* object, SceneObject* child) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYOBJECTREMOVEDFROMCHILD__SCENEOBJECT_SCENEOBJECT_);
		method.addObjectParameter(object);
		method.addObjectParameter(child);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->notifyObjectRemovedFromChild(object, child);
}

void SceneObject::synchronizedUIListen(SceneObject* player, int value) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SYNCHRONIZEDUILISTEN__SCENEOBJECT_INT_);
		method.addObjectParameter(player);
		method.addSignedIntParameter(value);

		method.executeWithVoidReturn();
	} else
		_implementation->synchronizedUIListen(player, value);
}

void SceneObject::synchronizedUIStopListen(SceneObject* player, int value) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SYNCHRONIZEDUISTOPLISTEN__SCENEOBJECT_INT_);
		method.addObjectParameter(player);
		method.addSignedIntParameter(value);

		method.executeWithVoidReturn();
	} else
		_implementation->synchronizedUIStopListen(player, value);
}

void SceneObject::updateToDatabase() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_UPDATETODATABASE__);

		method.executeWithVoidReturn();
	} else
		_implementation->updateToDatabase();
}

void SceneObject::updateToDatabaseWithoutChildren() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_UPDATETODATABASEWITHOUTCHILDREN__);

		method.executeWithVoidReturn();
	} else
		_implementation->updateToDatabaseWithoutChildren();
}

void SceneObject::updateToDatabaseAllObjects(bool startTask) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_UPDATETODATABASEALLOBJECTS__BOOL_);
		method.addBooleanParameter(startTask);

		method.executeWithVoidReturn();
	} else
		_implementation->updateToDatabaseAllObjects(startTask);
}

void SceneObject::destroyPlayerCreatureFromDatabase(bool destroyContainedObjects) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_DESTROYPLAYERCREATUREFROMDATABASE__BOOL_);
		method.addBooleanParameter(destroyContainedObjects);

		method.executeWithVoidReturn();
	} else
		_implementation->destroyPlayerCreatureFromDatabase(destroyContainedObjects);
}

void SceneObject::destroyObjectFromDatabase(bool destroyContainedObjects) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_DESTROYOBJECTFROMDATABASE__BOOL_);
		method.addBooleanParameter(destroyContainedObjects);

		method.executeWithVoidReturn();
	} else
		_implementation->destroyObjectFromDatabase(destroyContainedObjects);
}

int SceneObject::canBeDestroyed(CreatureObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CANBEDESTROYED__CREATUREOBJECT_);
		method.addObjectParameter(player);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->canBeDestroyed(player);
}

BaseMessage* SceneObject::link(unsigned long long objectID, unsigned int containmentType) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_LINK__LONG_INT_);
		method.addUnsignedLongParameter(objectID);
		method.addUnsignedIntParameter(containmentType);

		return static_cast<BaseMessage*>(method.executeWithObjectReturn());
	} else
		return _implementation->link(objectID, containmentType);
}

void SceneObject::sendTo(SceneObject* player, bool doClose) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDTO__SCENEOBJECT_BOOL_);
		method.addObjectParameter(player);
		method.addBooleanParameter(doClose);

		method.executeWithVoidReturn();
	} else
		_implementation->sendTo(player, doClose);
}

void SceneObject::sendWithoutParentTo(SceneObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDWITHOUTPARENTTO__SCENEOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->sendWithoutParentTo(player);
}

void SceneObject::sendWithoutContainerObjectsTo(SceneObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDWITHOUTCONTAINEROBJECTSTO__SCENEOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->sendWithoutContainerObjectsTo(player);
}

void SceneObject::sendDestroyTo(SceneObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDDESTROYTO__SCENEOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->sendDestroyTo(player);
}

void SceneObject::sendBaselinesTo(SceneObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDBASELINESTO__SCENEOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->sendBaselinesTo(player);
}

void SceneObject::sendContainerObjectsTo(SceneObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDCONTAINEROBJECTSTO__SCENEOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->sendContainerObjectsTo(player);
}

void SceneObject::sendSlottedObjectsTo(SceneObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDSLOTTEDOBJECTSTO__SCENEOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->sendSlottedObjectsTo(player);
}

void SceneObject::sendToOwner(bool doClose) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDTOOWNER__BOOL_);
		method.addBooleanParameter(doClose);

		method.executeWithVoidReturn();
	} else
		_implementation->sendToOwner(doClose);
}

void SceneObject::sendAttributeListTo(CreatureObject* object) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDATTRIBUTELISTTO__CREATUREOBJECT_);
		method.addObjectParameter(object);

		method.executeWithVoidReturn();
	} else
		_implementation->sendAttributeListTo(object);
}

void SceneObject::fillAttributeList(AttributeListMessage* msg, CreatureObject* object) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->fillAttributeList(msg, object);
}

void SceneObject::setCustomObjectName(const UnicodeString& name, bool notifyClient) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCUSTOMOBJECTNAME__UNICODESTRING_BOOL_);
		method.addUnicodeParameter(name);
		method.addBooleanParameter(notifyClient);

		method.executeWithVoidReturn();
	} else
		_implementation->setCustomObjectName(name, notifyClient);
}

void SceneObject::fillObjectMenuResponse(ObjectMenuResponse* menuResponse, CreatureObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->fillObjectMenuResponse(menuResponse, player);
}

void SceneObject::openContainerTo(CreatureObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_OPENCONTAINERTO__CREATUREOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->openContainerTo(player);
}

byte SceneObject::checkContainerPermission(CreatureObject* player, unsigned short permission) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->checkContainerPermission(player, permission);
}

void SceneObject::closeContainerTo(CreatureObject* player, bool notify) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CLOSECONTAINERTO__CREATUREOBJECT_BOOL_);
		method.addObjectParameter(player);
		method.addBooleanParameter(notify);

		method.executeWithVoidReturn();
	} else
		_implementation->closeContainerTo(player, notify);
}

void SceneObject::notifyInsertToZone(Zone* zone) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYINSERTTOZONE__ZONE_);
		method.addObjectParameter(zone);

		method.executeWithVoidReturn();
	} else
		_implementation->notifyInsertToZone(zone);
}

void SceneObject::switchZone(const String& newTerrainName, float newPostionX, float newPositionZ, float newPositionY, unsigned long long parentID) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SWITCHZONE__STRING_FLOAT_FLOAT_FLOAT_LONG_);
		method.addAsciiParameter(newTerrainName);
		method.addFloatParameter(newPostionX);
		method.addFloatParameter(newPositionZ);
		method.addFloatParameter(newPositionY);
		method.addUnsignedLongParameter(parentID);

		method.executeWithVoidReturn();
	} else
		_implementation->switchZone(newTerrainName, newPostionX, newPositionZ, newPositionY, parentID);
}

void SceneObject::teleport(float newPositionX, float newPositionZ, float newPositionY, unsigned long long parentID) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_TELEPORT__FLOAT_FLOAT_FLOAT_LONG_);
		method.addFloatParameter(newPositionX);
		method.addFloatParameter(newPositionZ);
		method.addFloatParameter(newPositionY);
		method.addUnsignedLongParameter(parentID);

		method.executeWithVoidReturn();
	} else
		_implementation->teleport(newPositionX, newPositionZ, newPositionY, parentID);
}

void SceneObject::updateDirection(float fw, float fx, float fy, float fz) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_UPDATEDIRECTION__FLOAT_FLOAT_FLOAT_FLOAT_);
		method.addFloatParameter(fw);
		method.addFloatParameter(fx);
		method.addFloatParameter(fy);
		method.addFloatParameter(fz);

		method.executeWithVoidReturn();
	} else
		_implementation->updateDirection(fw, fx, fy, fz);
}

void SceneObject::updateDirection(float angleHeadingRadians) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_UPDATEDIRECTION__FLOAT_);
		method.addFloatParameter(angleHeadingRadians);

		method.executeWithVoidReturn();
	} else
		_implementation->updateDirection(angleHeadingRadians);
}

void SceneObject::notifyInsert(QuadTreeEntry* entry) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->notifyInsert(entry);
}

void SceneObject::notifyDissapear(QuadTreeEntry* entry) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->notifyDissapear(entry);
}

void SceneObject::notifyRemoveFromZone() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYREMOVEFROMZONE__);

		method.executeWithVoidReturn();
	} else
		_implementation->notifyRemoveFromZone();
}

void SceneObject::updateZone(bool lightUpdate, bool sendPackets) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_UPDATEZONE__BOOL_BOOL_);
		method.addBooleanParameter(lightUpdate);
		method.addBooleanParameter(sendPackets);

		method.executeWithVoidReturn();
	} else
		_implementation->updateZone(lightUpdate, sendPackets);
}

void SceneObject::updateZoneWithParent(SceneObject* newParent, bool lightUpdate, bool sendPackets) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_UPDATEZONEWITHPARENT__SCENEOBJECT_BOOL_BOOL_);
		method.addObjectParameter(newParent);
		method.addBooleanParameter(lightUpdate);
		method.addBooleanParameter(sendPackets);

		method.executeWithVoidReturn();
	} else
		_implementation->updateZoneWithParent(newParent, lightUpdate, sendPackets);
}

void SceneObject::broadcastMessage(BasePacket* message, bool sendSelf, bool lockZone) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_BROADCASTMESSAGE__BASEPACKET_BOOL_BOOL_);
		method.addObjectParameter(message);
		method.addBooleanParameter(sendSelf);
		method.addBooleanParameter(lockZone);

		method.executeWithVoidReturn();
	} else
		_implementation->broadcastMessage(message, sendSelf, lockZone);
}

void SceneObject::broadcastMessagePrivate(BasePacket* message, SceneObject* selfObject, bool lockZone) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_BROADCASTMESSAGEPRIVATE__BASEPACKET_SCENEOBJECT_BOOL_);
		method.addObjectParameter(message);
		method.addObjectParameter(selfObject);
		method.addBooleanParameter(lockZone);

		method.executeWithVoidReturn();
	} else
		_implementation->broadcastMessagePrivate(message, selfObject, lockZone);
}

void SceneObject::broadcastObject(SceneObject* object, bool sendSelf) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_BROADCASTOBJECT__SCENEOBJECT_BOOL_);
		method.addObjectParameter(object);
		method.addBooleanParameter(sendSelf);

		method.executeWithVoidReturn();
	} else
		_implementation->broadcastObject(object, sendSelf);
}

void SceneObject::broadcastObjectPrivate(SceneObject* object, SceneObject* selfObject) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_BROADCASTOBJECTPRIVATE__SCENEOBJECT_SCENEOBJECT_);
		method.addObjectParameter(object);
		method.addObjectParameter(selfObject);

		method.executeWithVoidReturn();
	} else
		_implementation->broadcastObjectPrivate(object, selfObject);
}

void SceneObject::broadcastDestroy(SceneObject* object, bool sendSelf) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_BROADCASTDESTROY__SCENEOBJECT_BOOL_);
		method.addObjectParameter(object);
		method.addBooleanParameter(sendSelf);

		method.executeWithVoidReturn();
	} else
		_implementation->broadcastDestroy(object, sendSelf);
}

void SceneObject::broadcastDestroyPrivate(SceneObject* object, SceneObject* selfObject) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_BROADCASTDESTROYPRIVATE__SCENEOBJECT_SCENEOBJECT_);
		method.addObjectParameter(object);
		method.addObjectParameter(selfObject);

		method.executeWithVoidReturn();
	} else
		_implementation->broadcastDestroyPrivate(object, selfObject);
}

void SceneObject::broadcastMessages(Vector<BasePacket*>* messages, bool sendSelf) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->broadcastMessages(messages, sendSelf);
}

void SceneObject::broadcastMessagesPrivate(Vector<BasePacket*>* messages, SceneObject* selfObject) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->broadcastMessagesPrivate(messages, selfObject);
}

void SceneObject::sendMessage(BasePacket* msg) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SENDMESSAGE__BASEPACKET_);
		method.addObjectParameter(msg);

		method.executeWithVoidReturn();
	} else
		_implementation->sendMessage(msg);
}

int SceneObject::compareTo(SceneObject* obj) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_COMPARETO__SCENEOBJECT_);
		method.addObjectParameter(obj);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->compareTo(obj);
}

void SceneObject::getSlottedObjects(VectorMap<String, ManagedReference<SceneObject* > >& objects) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->getSlottedObjects(objects);
}

unsigned long long SceneObject::getParentID() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETPARENTID__);

		return method.executeWithUnsignedLongReturn();
	} else
		return _implementation->getParentID();
}

void SceneObject::addPendingTask(const String& name, Task* task, int miliseconds) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->addPendingTask(name, task, miliseconds);
}

void SceneObject::removePendingTask(const String& name) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->removePendingTask(name);
}

Task* SceneObject::getPendingTask(const String& name) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getPendingTask(name);
}

bool SceneObject::containsPendingTask(const String& name) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CONTAINSPENDINGTASK__STRING_);
		method.addAsciiParameter(name);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->containsPendingTask(name);
}

void SceneObject::showFlyText(const String& file, const String& uax, byte red, byte green, byte blue) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SHOWFLYTEXT__STRING_STRING_BYTE_BYTE_BYTE_);
		method.addAsciiParameter(file);
		method.addAsciiParameter(uax);
		method.addByteParameter(red);
		method.addByteParameter(green);
		method.addByteParameter(blue);

		method.executeWithVoidReturn();
	} else
		_implementation->showFlyText(file, uax, red, green, blue);
}

int SceneObject::getContainedObjectsRecursive() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCONTAINEDOBJECTSRECURSIVE__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getContainedObjectsRecursive();
}

Facade* SceneObject::getActiveSession(unsigned int type) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETACTIVESESSION__INT_);
		method.addUnsignedIntParameter(type);

		return static_cast<Facade*>(method.executeWithObjectReturn());
	} else
		return _implementation->getActiveSession(type);
}

void SceneObject::addActiveSession(unsigned int type, Facade* session) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ADDACTIVESESSION__INT_FACADE_);
		method.addUnsignedIntParameter(type);
		method.addObjectParameter(session);

		method.executeWithVoidReturn();
	} else
		_implementation->addActiveSession(type, session);
}

bool SceneObject::containsActiveSession(unsigned int type) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CONTAINSACTIVESESSION__INT_);
		method.addUnsignedIntParameter(type);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->containsActiveSession(type);
}

bool SceneObject::dropActiveSession(unsigned int type) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_DROPACTIVESESSION__INT_);
		method.addUnsignedIntParameter(type);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->dropActiveSession(type);
}

int SceneObject::getActiveSessionsCount() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETACTIVESESSIONSCOUNT__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getActiveSessionsCount();
}

VectorMap<unsigned int, ManagedReference<Facade* > >* SceneObject::getObjectActiveSessions() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getObjectActiveSessions();
}

int SceneObject::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HANDLEOBJECTMENUSELECT__CREATUREOBJECT_BYTE_);
		method.addObjectParameter(player);
		method.addByteParameter(selectedID);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->handleObjectMenuSelect(player, selectedID);
}

float SceneObject::getDistanceTo(SceneObject* object) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETDISTANCETO__SCENEOBJECT_);
		method.addObjectParameter(object);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getDistanceTo(object);
}

float SceneObject::getDistanceTo(Coordinate* coordinate) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getDistanceTo(coordinate);
}

void SceneObject::updateVehiclePosition(bool sendPackets) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_UPDATEVEHICLEPOSITION__BOOL_);
		method.addBooleanParameter(sendPackets);

		method.executeWithVoidReturn();
	} else
		_implementation->updateVehiclePosition(sendPackets);
}

int SceneObject::notifyObjectInserted(SceneObject* object) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYOBJECTINSERTED__SCENEOBJECT_);
		method.addObjectParameter(object);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->notifyObjectInserted(object);
}

int SceneObject::notifyObjectRemoved(SceneObject* object) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYOBJECTREMOVED__SCENEOBJECT_);
		method.addObjectParameter(object);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->notifyObjectRemoved(object);
}

void SceneObject::addActiveArea(ActiveArea* area) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ADDACTIVEAREA__ACTIVEAREA_);
		method.addObjectParameter(area);

		method.executeWithVoidReturn();
	} else
		_implementation->addActiveArea(area);
}

void SceneObject::dropActiveArea(ActiveArea* area) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_DROPACTIVEAREA__ACTIVEAREA_);
		method.addObjectParameter(area);

		method.executeWithVoidReturn();
	} else
		_implementation->dropActiveArea(area);
}

bool SceneObject::hasActiveArea(ActiveArea* area) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HASACTIVEAREA__ACTIVEAREA_);
		method.addObjectParameter(area);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->hasActiveArea(area);
}

bool SceneObject::hasActiveArea(unsigned long long objectid) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HASACTIVEAREA__LONG_);
		method.addUnsignedLongParameter(objectid);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->hasActiveArea(objectid);
}

Vector<ManagedReference<ActiveArea* > >* SceneObject::getActiveAreas() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getActiveAreas();
}

int SceneObject::getActiveAreasSize() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETACTIVEAREASSIZE__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getActiveAreasSize();
}

ActiveArea* SceneObject::getActiveRegion() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETACTIVEREGION__);

		return static_cast<ActiveArea*>(method.executeWithObjectReturn());
	} else
		return _implementation->getActiveRegion();
}

ManagedWeakReference<CityRegion* > SceneObject::getCityRegion() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getCityRegion();
}

void SceneObject::setCityRegion(CityRegion* region) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->setCityRegion(region);
}

Zone* SceneObject::getZone() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETZONE__);

		return static_cast<Zone*>(method.executeWithObjectReturn());
	} else
		return _implementation->getZone();
}

Zone* SceneObject::getLocalZone() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETLOCALZONE__);

		return static_cast<Zone*>(method.executeWithObjectReturn());
	} else
		return _implementation->getLocalZone();
}

unsigned long long SceneObject::getObjectID() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETOBJECTID__);

		return method.executeWithUnsignedLongReturn();
	} else
		return _implementation->getObjectID();
}

Vector3 SceneObject::getCoordinate(float distance, float angleDegrees) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getCoordinate(distance, angleDegrees);
}

Vector3 SceneObject::getWorldCoordinate(float distance, float angleDegrees) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getWorldCoordinate(distance, angleDegrees);
}

float SceneObject::getWorldPositionX() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETWORLDPOSITIONX__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getWorldPositionX();
}

float SceneObject::getWorldPositionY() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETWORLDPOSITIONY__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getWorldPositionY();
}

float SceneObject::getWorldPositionZ() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETWORLDPOSITIONZ__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getWorldPositionZ();
}

Vector3 SceneObject::getWorldPosition() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getWorldPosition();
}

float SceneObject::getDirectionX() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETDIRECTIONX__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getDirectionX();
}

float SceneObject::getDirectionZ() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETDIRECTIONZ__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getDirectionZ();
}

float SceneObject::getDirectionY() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETDIRECTIONY__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getDirectionY();
}

float SceneObject::getDirectionW() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETDIRECTIONW__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getDirectionW();
}

Quaternion* SceneObject::getDirection() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getDirection();
}

unsigned int SceneObject::getClientObjectCRC() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCLIENTOBJECTCRC__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getClientObjectCRC();
}

unsigned int SceneObject::getServerObjectCRC() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETSERVEROBJECTCRC__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getServerObjectCRC();
}

bool SceneObject::isWaypointObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISWAYPOINTOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isWaypointObject();
}

StringId* SceneObject::getObjectName() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getObjectName();
}

String SceneObject::getObjectNameStringIdFile() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETOBJECTNAMESTRINGIDFILE__);

		String _return_getObjectNameStringIdFile;
		method.executeWithAsciiReturn(_return_getObjectNameStringIdFile);
		return _return_getObjectNameStringIdFile;
	} else
		return _implementation->getObjectNameStringIdFile();
}

String SceneObject::getObjectNameStringIdName() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETOBJECTNAMESTRINGIDNAME__);

		String _return_getObjectNameStringIdName;
		method.executeWithAsciiReturn(_return_getObjectNameStringIdName);
		return _return_getObjectNameStringIdName;
	} else
		return _implementation->getObjectNameStringIdName();
}

String SceneObject::getDetailedDescription() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getDetailedDescription();
}

void SceneObject::setDetailedDescription(const String& detail) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETDETAILEDDESCRIPTION__STRING_);
		method.addAsciiParameter(detail);

		method.executeWithVoidReturn();
	} else
		_implementation->setDetailedDescription(detail);
}

int SceneObject::getArrangementDescriptorSize() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETARRANGEMENTDESCRIPTORSIZE__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getArrangementDescriptorSize();
}

String SceneObject::getArrangementDescriptor(int idx) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETARRANGEMENTDESCRIPTOR__INT_);
		method.addSignedIntParameter(idx);

		String _return_getArrangementDescriptor;
		method.executeWithAsciiReturn(_return_getArrangementDescriptor);
		return _return_getArrangementDescriptor;
	} else
		return _implementation->getArrangementDescriptor(idx);
}

String SceneObject::getSlotDescriptor(int idx) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETSLOTDESCRIPTOR__INT_);
		method.addSignedIntParameter(idx);

		String _return_getSlotDescriptor;
		method.executeWithAsciiReturn(_return_getSlotDescriptor);
		return _return_getSlotDescriptor;
	} else
		return _implementation->getSlotDescriptor(idx);
}

bool SceneObject::hasSlotDescriptor(const String& descr) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HASSLOTDESCRIPTOR__STRING_);
		method.addAsciiParameter(descr);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->hasSlotDescriptor(descr);
}

bool SceneObject::hasArrangementDescriptor(const String& descr) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HASARRANGEMENTDESCRIPTOR__STRING_);
		method.addAsciiParameter(descr);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->hasArrangementDescriptor(descr);
}

VectorMap<String, ManagedReference<SceneObject* > >* SceneObject::getSlottedObjects() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getSlottedObjects();
}

SceneObject* SceneObject::getSlottedObject(const String& slot) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETSLOTTEDOBJECT__STRING_);
		method.addAsciiParameter(slot);

		return static_cast<SceneObject*>(method.executeWithObjectReturn());
	} else
		return _implementation->getSlottedObject(slot);
}

int SceneObject::getSlotDescriptorSize() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETSLOTDESCRIPTORSIZE__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getSlotDescriptorSize();
}

SceneObject* SceneObject::getSlottedObject(int idx) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETSLOTTEDOBJECT__INT_);
		method.addSignedIntParameter(idx);

		return static_cast<SceneObject*>(method.executeWithObjectReturn());
	} else
		return _implementation->getSlottedObject(idx);
}

void SceneObject::dropSlottedObject(const String& arrengementDescriptor) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_DROPSLOTTEDOBJECT__STRING_);
		method.addAsciiParameter(arrengementDescriptor);

		method.executeWithVoidReturn();
	} else
		_implementation->dropSlottedObject(arrengementDescriptor);
}

void SceneObject::removeSlottedObject(int index) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_REMOVESLOTTEDOBJECT__INT_);
		method.addSignedIntParameter(index);

		method.executeWithVoidReturn();
	} else
		_implementation->removeSlottedObject(index);
}

int SceneObject::getContainerObjectsSize() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCONTAINEROBJECTSSIZE__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getContainerObjectsSize();
}

int SceneObject::getSlottedObjectsSize() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETSLOTTEDOBJECTSSIZE__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getSlottedObjectsSize();
}

bool SceneObject::hasFullContainerObjects() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HASFULLCONTAINEROBJECTS__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->hasFullContainerObjects();
}

unsigned int SceneObject::getContainerVolumeLimit() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCONTAINERVOLUMELIMIT__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getContainerVolumeLimit();
}

SceneObject* SceneObject::getContainerObject(int idx) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCONTAINEROBJECT__INT_);
		method.addSignedIntParameter(idx);

		return static_cast<SceneObject*>(method.executeWithObjectReturn());
	} else
		return _implementation->getContainerObject(idx);
}

VectorMap<unsigned long long, ManagedReference<SceneObject* > >* SceneObject::getContainerObjects() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getContainerObjects();
}

bool SceneObject::hasObjectInContainer(unsigned long long objectID) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HASOBJECTINCONTAINER__LONG_);
		method.addUnsignedLongParameter(objectID);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->hasObjectInContainer(objectID);
}

bool SceneObject::hasObjectInSlottedContainer(SceneObject* object) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_HASOBJECTINSLOTTEDCONTAINER__SCENEOBJECT_);
		method.addObjectParameter(object);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->hasObjectInSlottedContainer(object);
}

SceneObject* SceneObject::getContainerObject(unsigned long long objectID) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCONTAINEROBJECT__LONG_);
		method.addUnsignedLongParameter(objectID);

		return static_cast<SceneObject*>(method.executeWithObjectReturn());
	} else
		return _implementation->getContainerObject(objectID);
}

void SceneObject::removeAllContainerObjects() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_REMOVEALLCONTAINEROBJECTS__);

		method.executeWithVoidReturn();
	} else
		_implementation->removeAllContainerObjects();
}

void SceneObject::putInContainer(SceneObject* obj, unsigned long long key) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_PUTINCONTAINER__SCENEOBJECT_LONG_);
		method.addObjectParameter(obj);
		method.addUnsignedLongParameter(key);

		method.executeWithVoidReturn();
	} else
		_implementation->putInContainer(obj, key);
}

void SceneObject::removeFromContainerObjects(int index) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_REMOVEFROMCONTAINEROBJECTS__INT_);
		method.addSignedIntParameter(index);

		method.executeWithVoidReturn();
	} else
		_implementation->removeFromContainerObjects(index);
}

void SceneObject::setContainerVolumeLimit(int lim) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINERVOLUMELIMIT__INT_);
		method.addSignedIntParameter(lim);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainerVolumeLimit(lim);
}

void SceneObject::setContainerType(int type) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINERTYPE__INT_);
		method.addSignedIntParameter(type);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainerType(type);
}

unsigned int SceneObject::getContainerType() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCONTAINERTYPE__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getContainerType();
}

ZoneClientSession* SceneObject::getClient() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCLIENT__);

		return static_cast<ZoneClientSession*>(method.executeWithObjectReturn());
	} else
		return _implementation->getClient();
}

unsigned int SceneObject::getGameObjectType() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETGAMEOBJECTTYPE__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getGameObjectType();
}

unsigned int SceneObject::getClientGameObjectType() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCLIENTGAMEOBJECTTYPE__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getClientGameObjectType();
}

unsigned int SceneObject::getContainmentType() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCONTAINMENTTYPE__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getContainmentType();
}

float SceneObject::getDirectionAngle() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETDIRECTIONANGLE__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getDirectionAngle();
}

float SceneObject::getSpecialDirectionAngle() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETSPECIALDIRECTIONANGLE__);

		return method.executeWithFloatReturn();
	} else
		return _implementation->getSpecialDirectionAngle();
}

void SceneObject::rotate(int degrees) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ROTATE__INT_);
		method.addSignedIntParameter(degrees);

		method.executeWithVoidReturn();
	} else
		_implementation->rotate(degrees);
}

void SceneObject::faceObject(SceneObject* obj) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_FACEOBJECT__SCENEOBJECT_);
		method.addObjectParameter(obj);

		method.executeWithVoidReturn();
	} else
		_implementation->faceObject(obj);
}

void SceneObject::notifySelfPositionUpdate() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYSELFPOSITIONUPDATE__);

		method.executeWithVoidReturn();
	} else
		_implementation->notifySelfPositionUpdate();
}

void SceneObject::notifyPositionUpdate(QuadTreeEntry* entry) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYPOSITIONUPDATE__QUADTREEENTRY_);
		method.addObjectParameter(entry);

		method.executeWithVoidReturn();
	} else
		_implementation->notifyPositionUpdate(entry);
}

void SceneObject::notifyCloseContainer(CreatureObject* player) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_NOTIFYCLOSECONTAINER__CREATUREOBJECT_);
		method.addObjectParameter(player);

		method.executeWithVoidReturn();
	} else
		_implementation->notifyCloseContainer(player);
}

unsigned int SceneObject::getMovementCounter() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETMOVEMENTCOUNTER__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getMovementCounter();
}

ManagedWeakReference<SceneObject* > SceneObject::getParent() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETPARENT__);

		return static_cast<SceneObject*>(method.executeWithObjectReturn());
	} else
		return _implementation->getParent();
}

ZoneServer* SceneObject::getZoneServer() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETZONESERVER__);

		return static_cast<ZoneServer*>(method.executeWithObjectReturn());
	} else
		return _implementation->getZoneServer();
}

ManagedWeakReference<SceneObject* > SceneObject::getRootParent() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETROOTPARENT__);

		return static_cast<SceneObject*>(method.executeWithObjectReturn());
	} else
		return _implementation->getRootParent();
}

ManagedWeakReference<SceneObject* > SceneObject::getParentRecursively(unsigned int gameObjectType) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETPARENTRECURSIVELY__INT_);
		method.addUnsignedIntParameter(gameObjectType);

		return static_cast<SceneObject*>(method.executeWithObjectReturn());
	} else
		return _implementation->getParentRecursively(gameObjectType);
}

bool SceneObject::isASubChildOf(SceneObject* object) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISASUBCHILDOF__SCENEOBJECT_);
		method.addObjectParameter(object);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isASubChildOf(object);
}

ReadWriteLock* SceneObject::getContainerLock() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getContainerLock();
}

UnicodeString SceneObject::getCustomObjectName() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETCUSTOMOBJECTNAME__);

		UnicodeString _return_getCustomObjectName;
		method.executeWithUnicodeReturn(_return_getCustomObjectName);
		return _return_getCustomObjectName;
	} else
		return _implementation->getCustomObjectName();
}

String SceneObject::getLoggingName() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETLOGGINGNAME__);

		String _return_getLoggingName;
		method.executeWithAsciiReturn(_return_getLoggingName);
		return _return_getLoggingName;
	} else
		return _implementation->getLoggingName();
}

bool SceneObject::isPlayerCreature() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISPLAYERCREATURE__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isPlayerCreature();
}

bool SceneObject::isVendor() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->isVendor();
}

ZoneComponent* SceneObject::getZoneComponent() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getZoneComponent();
}

ObjectMenuComponent* SceneObject::getObjectMenuComponent() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getObjectMenuComponent();
}

DataObjectComponentReference* SceneObject::getDataObjectComponent() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getDataObjectComponent();
}

void SceneObject::setObjectMenuComponent(const String& name) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->setObjectMenuComponent(name);
}

void SceneObject::setContainerComponent(const String& name) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->setContainerComponent(name);
}

bool SceneObject::isNoTrade() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISNOTRADE__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isNoTrade();
}

bool SceneObject::isContainerFull() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCONTAINERFULL__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isContainerFull();
}

bool SceneObject::isShuttleInstallation() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISSHUTTLEINSTALLATION__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isShuttleInstallation();
}

bool SceneObject::isPlayerObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISPLAYEROBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isPlayerObject();
}

bool SceneObject::isActiveArea() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISACTIVEAREA__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isActiveArea();
}

bool SceneObject::isRegion() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISREGION__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isRegion();
}

bool SceneObject::isCreatureObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCREATUREOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCreatureObject();
}

bool SceneObject::isAiAgent() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISAIAGENT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isAiAgent();
}

bool SceneObject::isShipObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISSHIPOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isShipObject();
}

bool SceneObject::isVehicleObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISVEHICLEOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isVehicleObject();
}

bool SceneObject::isBuildingObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISBUILDINGOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isBuildingObject();
}

bool SceneObject::isCloningBuildingObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCLONINGBUILDINGOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCloningBuildingObject();
}

bool SceneObject::isGarage() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISGARAGE__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isGarage();
}

bool SceneObject::isWeaponObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISWEAPONOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isWeaponObject();
}

bool SceneObject::isWearableObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISWEARABLEOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isWearableObject();
}

bool SceneObject::isArmorObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISARMOROBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isArmorObject();
}

bool SceneObject::isRobeObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISROBEOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isRobeObject();
}

bool SceneObject::isLightsaberCrystalObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISLIGHTSABERCRYSTALOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isLightsaberCrystalObject();
}

bool SceneObject::isFireworkObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISFIREWORKOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isFireworkObject();
}

bool SceneObject::isPsgArmorObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISPSGARMOROBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isPsgArmorObject();
}

bool SceneObject::isCellObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCELLOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCellObject();
}

bool SceneObject::isTangibleObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISTANGIBLEOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isTangibleObject();
}

bool SceneObject::isResourceContainer() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISRESOURCECONTAINER__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isResourceContainer();
}

bool SceneObject::isResourceSpawn() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISRESOURCESPAWN__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isResourceSpawn();
}

bool SceneObject::isComponent() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCOMPONENT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isComponent();
}

bool SceneObject::isIntangibleObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISINTANGIBLEOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isIntangibleObject();
}

bool SceneObject::isInstrument() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISINSTRUMENT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isInstrument();
}

bool SceneObject::isBazaarTerminal() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISBAZAARTERMINAL__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isBazaarTerminal();
}

bool SceneObject::isLiveSample() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISLIVESAMPLE__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isLiveSample();
}

bool SceneObject::isInstallationObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISINSTALLATIONOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isInstallationObject();
}

bool SceneObject::isHarvesterObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISHARVESTEROBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isHarvesterObject();
}

bool SceneObject::isGeneratorObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISGENERATOROBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isGeneratorObject();
}

bool SceneObject::isCityTerminal() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCITYTERMINAL__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCityTerminal();
}

bool SceneObject::isCityVoteTerminal() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCITYVOTETERMINAL__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCityVoteTerminal();
}

bool SceneObject::isFactory() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISFACTORY__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isFactory();
}

bool SceneObject::isFactoryCrate() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISFACTORYCRATE__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isFactoryCrate();
}

bool SceneObject::isFishingPoleObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISFISHINGPOLEOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isFishingPoleObject();
}

bool SceneObject::isDeedObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISDEEDOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isDeedObject();
}

bool SceneObject::isVehicleDeedObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISVEHICLEDEEDOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isVehicleDeedObject();
}

bool SceneObject::isBuildingDeed() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISBUILDINGDEED__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isBuildingDeed();
}

bool SceneObject::isSignObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISSIGNOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isSignObject();
}

bool SceneObject::isInstallationDeed() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISINSTALLATIONDEED__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isInstallationDeed();
}

bool SceneObject::isCraftingTool() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCRAFTINGTOOL__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCraftingTool();
}

bool SceneObject::isCraftingStation() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCRAFTINGSTATION__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCraftingStation();
}

bool SceneObject::isManufactureSchematic() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISMANUFACTURESCHEMATIC__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isManufactureSchematic();
}

bool SceneObject::isStructureObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISSTRUCTUREOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isStructureObject();
}

bool SceneObject::isAuctionObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISAUCTIONOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isAuctionObject();
}

bool SceneObject::isFishingBait() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISFISHINGBAIT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isFishingBait();
}

bool SceneObject::isTrapObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISTRAPOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isTrapObject();
}

bool SceneObject::isRepairTool() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISREPAIRTOOL__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isRepairTool();
}

bool SceneObject::isCamoKit() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCAMOKIT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCamoKit();
}

bool SceneObject::isAttachment() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISATTACHMENT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isAttachment();
}

bool SceneObject::isDiceObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISDICEOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isDiceObject();
}

bool SceneObject::isCreatureHabitat() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCREATUREHABITAT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCreatureHabitat();
}

bool SceneObject::isCampKit() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCAMPKIT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCampKit();
}

bool SceneObject::isCampStructure() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCAMPSTRUCTURE__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isCampStructure();
}

ContainerPermissions* SceneObject::getContainerPermissions() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getContainerPermissions();
}

void SceneObject::setContainerDefaultAllowPermission(unsigned short perm) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINERDEFAULTALLOWPERMISSION__SHORT_);
		method.addUnsignedShortParameter(perm);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainerDefaultAllowPermission(perm);
}

void SceneObject::clearContainerDefaultAllowPermission(unsigned short perm) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CLEARCONTAINERDEFAULTALLOWPERMISSION__SHORT_);
		method.addUnsignedShortParameter(perm);

		method.executeWithVoidReturn();
	} else
		_implementation->clearContainerDefaultAllowPermission(perm);
}

void SceneObject::setContainerDefaultDenyPermission(unsigned short perm) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINERDEFAULTDENYPERMISSION__SHORT_);
		method.addUnsignedShortParameter(perm);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainerDefaultDenyPermission(perm);
}

void SceneObject::clearContainerDefaultDenyPermission(unsigned short perm) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CLEARCONTAINERDEFAULTDENYPERMISSION__SHORT_);
		method.addUnsignedShortParameter(perm);

		method.executeWithVoidReturn();
	} else
		_implementation->clearContainerDefaultDenyPermission(perm);
}

void SceneObject::setContainerInheritPermissionsFromParent(bool val) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINERINHERITPERMISSIONSFROMPARENT__BOOL_);
		method.addBooleanParameter(val);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainerInheritPermissionsFromParent(val);
}

void SceneObject::setContainerOwnerID(unsigned long long id) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINEROWNERID__LONG_);
		method.addUnsignedLongParameter(id);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainerOwnerID(id);
}

void SceneObject::setContainerAllowPermission(const String& group, unsigned short perm) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINERALLOWPERMISSION__STRING_SHORT_);
		method.addAsciiParameter(group);
		method.addUnsignedShortParameter(perm);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainerAllowPermission(group, perm);
}

void SceneObject::setContainerDenyPermission(const String& group, unsigned short perm) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINERDENYPERMISSION__STRING_SHORT_);
		method.addAsciiParameter(group);
		method.addUnsignedShortParameter(perm);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainerDenyPermission(group, perm);
}

void SceneObject::setGameObjectType(unsigned int type) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETGAMEOBJECTTYPE__INT_);
		method.addUnsignedIntParameter(type);

		method.executeWithVoidReturn();
	} else
		_implementation->setGameObjectType(type);
}

void SceneObject::setClientObjectCRC(unsigned int objCRC) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCLIENTOBJECTCRC__INT_);
		method.addUnsignedIntParameter(objCRC);

		method.executeWithVoidReturn();
	} else
		_implementation->setClientObjectCRC(objCRC);
}

void SceneObject::setServerObjectCRC(unsigned int objCRC) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETSERVEROBJECTCRC__INT_);
		method.addUnsignedIntParameter(objCRC);

		method.executeWithVoidReturn();
	} else
		_implementation->setServerObjectCRC(objCRC);
}

void SceneObject::setZoneProcessServer(ZoneProcessServer* srv) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->setZoneProcessServer(srv);
}

ZoneProcessServer* SceneObject::getZoneProcessServer() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getZoneProcessServer();
}

void SceneObject::setZone(Zone* zone) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETZONE__ZONE_);
		method.addObjectParameter(zone);

		method.executeWithVoidReturn();
	} else
		_implementation->setZone(zone);
}

void SceneObject::setObjectName(StringId& stringID) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->setObjectName(stringID);
}

void SceneObject::setDirection(float fw, float fx, float fy, float fz) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETDIRECTION__FLOAT_FLOAT_FLOAT_FLOAT_);
		method.addFloatParameter(fw);
		method.addFloatParameter(fx);
		method.addFloatParameter(fy);
		method.addFloatParameter(fz);

		method.executeWithVoidReturn();
	} else
		_implementation->setDirection(fw, fx, fy, fz);
}

void SceneObject::setDirection(float headingAngleRadians) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETDIRECTION__FLOAT_);
		method.addFloatParameter(headingAngleRadians);

		method.executeWithVoidReturn();
	} else
		_implementation->setDirection(headingAngleRadians);
}

void SceneObject::setDirection(const Quaternion& dir) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->setDirection(dir);
}

void SceneObject::setMovementCounter(unsigned int count) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETMOVEMENTCOUNTER__INT_);
		method.addUnsignedIntParameter(count);

		method.executeWithVoidReturn();
	} else
		_implementation->setMovementCounter(count);
}

void SceneObject::incrementMovementCounter() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_INCREMENTMOVEMENTCOUNTER__);

		method.executeWithVoidReturn();
	} else
		_implementation->incrementMovementCounter();
}

void SceneObject::setContainmentType(unsigned int type) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCONTAINMENTTYPE__INT_);
		method.addUnsignedIntParameter(type);

		method.executeWithVoidReturn();
	} else
		_implementation->setContainmentType(type);
}

void SceneObject::setLoggingName(const String& name) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETLOGGINGNAME__STRING_);
		method.addAsciiParameter(name);

		method.executeWithVoidReturn();
	} else
		_implementation->setLoggingName(name);
}

void SceneObject::setClientObject(bool val) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETCLIENTOBJECT__BOOL_);
		method.addBooleanParameter(val);

		method.executeWithVoidReturn();
	} else
		_implementation->setClientObject(val);
}

unsigned int SceneObject::getPlanetCRC() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETPLANETCRC__);

		return method.executeWithUnsignedIntReturn();
	} else
		return _implementation->getPlanetCRC();
}

bool SceneObject::isStaticObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISSTATICOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isStaticObject();
}

bool SceneObject::isContainerObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCONTAINEROBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isContainerObject();
}

bool SceneObject::isTerminal() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISTERMINAL__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isTerminal();
}

bool SceneObject::isGroupObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISGROUPOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isGroupObject();
}

bool SceneObject::isGuildObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISGUILDOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isGuildObject();
}

bool SceneObject::isControlDevice() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISCONTROLDEVICE__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isControlDevice();
}

bool SceneObject::isMissionTerminal() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISMISSIONTERMINAL__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isMissionTerminal();
}

bool SceneObject::isMissionObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISMISSIONOBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isMissionObject();
}

bool SceneObject::isActorObject() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISACTOROBJECT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isActorObject();
}

int SceneObject::getPlanetMapCategoryCRC() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETPLANETMAPCATEGORYCRC__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getPlanetMapCategoryCRC();
}

int SceneObject::getPlanetMapSubCategoryCRC() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETPLANETMAPSUBCATEGORYCRC__);

		return method.executeWithSignedIntReturn();
	} else
		return _implementation->getPlanetMapSubCategoryCRC();
}

void SceneObject::setPlanetMapCategory(PlanetMapCategory* pmc) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->setPlanetMapCategory(pmc);
}

void SceneObject::setPlanetMapSubCategory(PlanetMapCategory* pmc) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		_implementation->setPlanetMapSubCategory(pmc);
}

PlanetMapCategory* SceneObject::getPlanetMapCategory() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getPlanetMapCategory();
}

PlanetMapCategory* SceneObject::getPlanetMapSubCategory() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getPlanetMapSubCategory();
}

SortedVector<ManagedReference<SceneObject* > >* SceneObject::getChildObjects() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getChildObjects();
}

bool SceneObject::containsChildObject(SceneObject* obj) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CONTAINSCHILDOBJECT__SCENEOBJECT_);
		method.addObjectParameter(obj);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->containsChildObject(obj);
}

SharedObjectTemplate* SceneObject::getObjectTemplate() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getObjectTemplate();
}

SortedVector<ManagedReference<Observer* > >* SceneObject::getObservers(unsigned int eventType) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getObservers(eventType);
}

void SceneObject::createChildObjects() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_CREATECHILDOBJECTS__);

		method.executeWithVoidReturn();
	} else
		_implementation->createChildObjects();
}

Matrix4* SceneObject::getTransformForCollisionMatrix() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->getTransformForCollisionMatrix();
}

bool SceneObject::setTransformForCollisionMatrixIfNull(Matrix4* mat) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		throw ObjectNotLocalException(this);

	} else
		return _implementation->setTransformForCollisionMatrixIfNull(mat);
}

void SceneObject::initializeChildObject(SceneObject* controllerObject) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_INITIALIZECHILDOBJECT__SCENEOBJECT_);
		method.addObjectParameter(controllerObject);

		method.executeWithVoidReturn();
	} else
		_implementation->initializeChildObject(controllerObject);
}

bool SceneObject::isInWater() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_ISINWATER__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->isInWater();
}

String SceneObject::getDisplayedName() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_GETDISPLAYEDNAME__);

		String _return_getDisplayedName;
		method.executeWithAsciiReturn(_return_getDisplayedName);
		return _return_getDisplayedName;
	} else
		return _implementation->getDisplayedName();
}

bool SceneObject::doSendToClient() {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_DOSENDTOCLIENT__);

		return method.executeWithBooleanReturn();
	} else
		return _implementation->doSendToClient();
}

void SceneObject::setSendToClient(bool val) {
	SceneObjectImplementation* _implementation = static_cast<SceneObjectImplementation*>(_getImplementation());
	if (_implementation == NULL) {
		if (!deployed)
			throw ObjectNotDeployedException(this);

		DistributedMethod method(this, RPC_SETSENDTOCLIENT__BOOL_);
		method.addBooleanParameter(val);

		method.executeWithVoidReturn();
	} else
		_implementation->setSendToClient(val);
}

DistributedObjectServant* SceneObject::_getImplementation() {

	 if (!_updated) _updated = true;
	return _impl;
}

void SceneObject::_setImplementation(DistributedObjectServant* servant) {
	_impl = servant;
}

/*
 *	SceneObjectImplementation
 */

SceneObjectImplementation::SceneObjectImplementation(DummyConstructorParameter* param) : QuadTreeEntryImplementation(param) {
	_initializeImplementation();
}


SceneObjectImplementation::~SceneObjectImplementation() {
	SceneObjectImplementation::finalize();
}


void SceneObjectImplementation::_initializeImplementation() {
	_setClassHelper(SceneObjectHelper::instance());

	_this = NULL;

	_serializationHelperMethod();
}

void SceneObjectImplementation::_setStub(DistributedObjectStub* stub) {
	_this = static_cast<SceneObject*>(stub);
	QuadTreeEntryImplementation::_setStub(stub);
}

DistributedObjectStub* SceneObjectImplementation::_getStub() {
	return _this.get();
}

SceneObjectImplementation::operator const SceneObject*() {
	return _this.get();
}

void SceneObjectImplementation::lock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->lock(doLock);
}

void SceneObjectImplementation::lock(ManagedObject* obj) {
	_this.getReferenceUnsafeStaticCast()->lock(obj);
}

void SceneObjectImplementation::rlock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->rlock(doLock);
}

void SceneObjectImplementation::wlock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->wlock(doLock);
}

void SceneObjectImplementation::wlock(ManagedObject* obj) {
	_this.getReferenceUnsafeStaticCast()->wlock(obj);
}

void SceneObjectImplementation::unlock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->unlock(doLock);
}

void SceneObjectImplementation::runlock(bool doLock) {
	_this.getReferenceUnsafeStaticCast()->runlock(doLock);
}

void SceneObjectImplementation::_serializationHelperMethod() {
	QuadTreeEntryImplementation::_serializationHelperMethod();

	_setClassName("SceneObject");

}

void SceneObjectImplementation::readObject(ObjectInputStream* stream) {
	uint16 _varCount = stream->readShort();
	for (int i = 0; i < _varCount; ++i) {
		String _name;
		_name.parseFromBinaryStream(stream);

		uint32 _varSize = stream->readInt();

		int _currentOffset = stream->getOffset();

		if(SceneObjectImplementation::readObjectMember(stream, _name)) {
		}

		stream->setOffset(_currentOffset + _varSize);
	}

	initializeTransientMembers();
}

bool SceneObjectImplementation::readObjectMember(ObjectInputStream* stream, const String& _name) {
	if (QuadTreeEntryImplementation::readObjectMember(stream, _name))
		return true;

	if (_name == "SceneObject.sendToClient") {
		TypeInfo<bool >::parseFromBinaryStream(&sendToClient, stream);
		return true;
	}

	if (_name == "SceneObject.zone") {
		TypeInfo<ZoneReference >::parseFromBinaryStream(&zone, stream);
		return true;
	}

	if (_name == "SceneObject.dataObjectComponent") {
		TypeInfo<DataObjectComponentReference >::parseFromBinaryStream(&dataObjectComponent, stream);
		return true;
	}

	if (_name == "SceneObject.containerType") {
		TypeInfo<unsigned int >::parseFromBinaryStream(&containerType, stream);
		return true;
	}

	if (_name == "SceneObject.containerVolumeLimit") {
		TypeInfo<unsigned int >::parseFromBinaryStream(&containerVolumeLimit, stream);
		return true;
	}

	if (_name == "SceneObject.containerPermissions") {
		TypeInfo<ContainerPermissions >::parseFromBinaryStream(&containerPermissions, stream);
		return true;
	}

	if (_name == "SceneObject.serverObjectCRC") {
		TypeInfo<unsigned int >::parseFromBinaryStream(&serverObjectCRC, stream);
		return true;
	}

	if (_name == "SceneObject.clientObjectCRC") {
		TypeInfo<unsigned int >::parseFromBinaryStream(&clientObjectCRC, stream);
		return true;
	}

	if (_name == "SceneObject.direction") {
		TypeInfo<Quaternion >::parseFromBinaryStream(&direction, stream);
		return true;
	}

	if (_name == "SceneObject.movementCounter") {
		TypeInfo<unsigned int >::parseFromBinaryStream(&movementCounter, stream);
		return true;
	}

	if (_name == "SceneObject.objectName") {
		TypeInfo<StringId >::parseFromBinaryStream(&objectName, stream);
		return true;
	}

	if (_name == "SceneObject.staticObject") {
		TypeInfo<bool >::parseFromBinaryStream(&staticObject, stream);
		return true;
	}

	if (_name == "SceneObject.objectActiveSessions") {
		TypeInfo<VectorMap<unsigned int, ManagedReference<Facade* > > >::parseFromBinaryStream(&objectActiveSessions, stream);
		return true;
	}

	if (_name == "SceneObject.gameObjectType") {
		TypeInfo<unsigned int >::parseFromBinaryStream(&gameObjectType, stream);
		return true;
	}

	if (_name == "SceneObject.clientGameObjectType") {
		TypeInfo<unsigned int >::parseFromBinaryStream(&clientGameObjectType, stream);
		return true;
	}

	if (_name == "SceneObject.containmentType") {
		TypeInfo<unsigned int >::parseFromBinaryStream(&containmentType, stream);
		return true;
	}

	if (_name == "SceneObject.planetMapCategory") {
		TypeInfo<int >::parseFromBinaryStream(&planetMapCategory, stream);
		return true;
	}

	if (_name == "SceneObject.planetMapSubCategory") {
		TypeInfo<int >::parseFromBinaryStream(&planetMapSubCategory, stream);
		return true;
	}

	if (_name == "SceneObject.customName") {
		TypeInfo<UnicodeString >::parseFromBinaryStream(&customName, stream);
		return true;
	}

	if (_name == "SceneObject.activeAreas") {
		TypeInfo<SortedVector<ManagedReference<ActiveArea* > > >::parseFromBinaryStream(&activeAreas, stream);
		return true;
	}

	if (_name == "SceneObject.childObjects") {
		TypeInfo<SortedVector<ManagedReference<SceneObject* > > >::parseFromBinaryStream(&childObjects, stream);
		return true;
	}

	if (_name == "SceneObject.slottedObjects") {
		TypeInfo<VectorMap<String, ManagedReference<SceneObject* > > >::parseFromBinaryStream(&slottedObjects, stream);
		return true;
	}

	if (_name == "SceneObject.containerObjects") {
		TypeInfo<ContainerObjectsMap >::parseFromBinaryStream(&containerObjects, stream);
		return true;
	}


	return false;
}

void SceneObjectImplementation::writeObject(ObjectOutputStream* stream) {
	int _currentOffset = stream->getOffset();
	stream->writeShort(0);
	int _varCount = SceneObjectImplementation::writeObjectMembers(stream);
	stream->writeShort(_currentOffset, _varCount);
}

int SceneObjectImplementation::writeObjectMembers(ObjectOutputStream* stream) {
	int _count = QuadTreeEntryImplementation::writeObjectMembers(stream);

	String _name;
	int _offset;
	uint32 _totalSize;
	_name = "SceneObject.sendToClient";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<bool >::toBinaryStream(&sendToClient, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.zone";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<ZoneReference >::toBinaryStream(&zone, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.dataObjectComponent";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<DataObjectComponentReference >::toBinaryStream(&dataObjectComponent, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.containerType";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<unsigned int >::toBinaryStream(&containerType, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.containerVolumeLimit";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<unsigned int >::toBinaryStream(&containerVolumeLimit, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.containerPermissions";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<ContainerPermissions >::toBinaryStream(&containerPermissions, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.serverObjectCRC";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<unsigned int >::toBinaryStream(&serverObjectCRC, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.clientObjectCRC";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<unsigned int >::toBinaryStream(&clientObjectCRC, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.direction";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<Quaternion >::toBinaryStream(&direction, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.movementCounter";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<unsigned int >::toBinaryStream(&movementCounter, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.objectName";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<StringId >::toBinaryStream(&objectName, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.staticObject";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<bool >::toBinaryStream(&staticObject, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.objectActiveSessions";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<VectorMap<unsigned int, ManagedReference<Facade* > > >::toBinaryStream(&objectActiveSessions, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.gameObjectType";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<unsigned int >::toBinaryStream(&gameObjectType, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.clientGameObjectType";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<unsigned int >::toBinaryStream(&clientGameObjectType, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.containmentType";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<unsigned int >::toBinaryStream(&containmentType, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.planetMapCategory";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<int >::toBinaryStream(&planetMapCategory, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.planetMapSubCategory";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<int >::toBinaryStream(&planetMapSubCategory, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.customName";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<UnicodeString >::toBinaryStream(&customName, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.activeAreas";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<SortedVector<ManagedReference<ActiveArea* > > >::toBinaryStream(&activeAreas, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.childObjects";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<SortedVector<ManagedReference<SceneObject* > > >::toBinaryStream(&childObjects, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.slottedObjects";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<VectorMap<String, ManagedReference<SceneObject* > > >::toBinaryStream(&slottedObjects, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);

	_name = "SceneObject.containerObjects";
	_name.toBinaryStream(stream);
	_offset = stream->getOffset();
	stream->writeInt(0);
	TypeInfo<ContainerObjectsMap >::toBinaryStream(&containerObjects, stream);
	_totalSize = (uint32) (stream->getOffset() - (_offset + 4));
	stream->writeInt(_offset, _totalSize);


	return _count + 23;
}

SceneObjectImplementation::SceneObjectImplementation() {
	_initializeImplementation();
	// server/zone/objects/scene/SceneObject.idl():  		initializePrivateData();
	initializePrivateData();
}

void SceneObjectImplementation::finalize() {
}

void SceneObjectImplementation::info(const String& msg, bool forced) {
	// server/zone/objects/scene/SceneObject.idl():  		Logger.info(msg, forced);
	Logger::info(msg, forced);
}

void SceneObjectImplementation::error(const String& msg) {
	// server/zone/objects/scene/SceneObject.idl():  		Logger.error(msg);
	Logger::error(msg);
}

void SceneObjectImplementation::destroyObjectFromWorld(bool sendSelfDestroy) {
	// server/zone/objects/scene/SceneObject.idl():  		zoneComponent.destroyObjectFromWorld(this, sendSelfDestroy);
	zoneComponent->destroyObjectFromWorld(_this.get(), sendSelfDestroy);
}

int SceneObjectImplementation::notifyObjectInsertedToChild(SceneObject* object, SceneObject* child, SceneObject* oldParent) {
	// server/zone/objects/scene/SceneObject.idl():  		return 0;
	return 0;
}

int SceneObjectImplementation::notifyObjectRemovedFromChild(SceneObject* object, SceneObject* child) {
	// server/zone/objects/scene/SceneObject.idl():  		return 0;
	return 0;
}

void SceneObjectImplementation::synchronizedUIListen(SceneObject* player, int value) {
	// server/zone/objects/scene/SceneObject.idl():  		Logger.info("Unhandled synchronizedUIListen", true);
	Logger::info("Unhandled synchronizedUIListen", true);
}

void SceneObjectImplementation::synchronizedUIStopListen(SceneObject* player, int value) {
	// server/zone/objects/scene/SceneObject.idl():  		Logger.info("Unhandled synchronizedUIStopListen", true);
	Logger::info("Unhandled synchronizedUIStopListen", true);
}

int SceneObjectImplementation::canBeDestroyed(CreatureObject* player) {
	// server/zone/objects/scene/SceneObject.idl():  		return 0;
	return 0;
}

void SceneObjectImplementation::sendBaselinesTo(SceneObject* player) {
}

void SceneObjectImplementation::sendToOwner(bool doClose) {
}

void SceneObjectImplementation::fillAttributeList(AttributeListMessage* msg, CreatureObject* object) {
}

void SceneObjectImplementation::setCustomObjectName(const UnicodeString& name, bool notifyClient) {
	// server/zone/objects/scene/SceneObject.idl():  		customName = name;
	customName = name;
}

byte SceneObjectImplementation::checkContainerPermission(CreatureObject* player, unsigned short permission) {
	// server/zone/objects/scene/SceneObject.idl():  		return containerComponent.checkContainerPermission(this, player, permission);
	return containerComponent->checkContainerPermission(_this.get(), player, permission);
}

void SceneObjectImplementation::notifyInsert(QuadTreeEntry* entry) {
	// server/zone/objects/scene/SceneObject.idl():  		zoneComponent.notifyInsert(this, entry);
	zoneComponent->notifyInsert(_this.get(), entry);
}

void SceneObjectImplementation::notifyDissapear(QuadTreeEntry* entry) {
	// server/zone/objects/scene/SceneObject.idl():  		zoneComponent.notifyDissapear(this, entry);
	zoneComponent->notifyDissapear(_this.get(), entry);
}

int SceneObjectImplementation::compareTo(SceneObject* obj) {
	// server/zone/objects/scene/SceneObject.idl():  			return 0;
	if (getObjectID() < obj->getObjectID())	// server/zone/objects/scene/SceneObject.idl():  			return 1;
	return 1;

	else 	// server/zone/objects/scene/SceneObject.idl():  			return 0;
	if (getObjectID() > obj->getObjectID())	// server/zone/objects/scene/SceneObject.idl():  			return -1;
	return -1;

	else 	// server/zone/objects/scene/SceneObject.idl():  			return 0;
	return 0;
}

unsigned long long SceneObjectImplementation::getParentID() {
	// server/zone/objects/scene/SceneObject.idl():  			return 0;
	if (QuadTreeEntryImplementation::parent.getForUpdate() != NULL){
	// server/zone/objects/scene/SceneObject.idl():  			return super.parent.getObjectID();
	return QuadTreeEntryImplementation::parent.getForUpdate().get()->getObjectID();
}

	else 	// server/zone/objects/scene/SceneObject.idl():  			return 0;
	return 0;
}

void SceneObjectImplementation::addPendingTask(const String& name, Task* task, int miliseconds) {
	// server/zone/objects/scene/SceneObject.idl():  		pendingTasks.put(name, task);
	(&pendingTasks)->put(name, task);
	// server/zone/objects/scene/SceneObject.idl():  		task.schedule(miliseconds);
	task->schedule(miliseconds);
}

void SceneObjectImplementation::removePendingTask(const String& name) {
	// server/zone/objects/scene/SceneObject.idl():  		pendingTasks.drop(name);
	(&pendingTasks)->drop(name);
}

Task* SceneObjectImplementation::getPendingTask(const String& name) {
	// server/zone/objects/scene/SceneObject.idl():  		return pendingTasks.get(name);
	return (&pendingTasks)->get(name);
}

bool SceneObjectImplementation::containsPendingTask(const String& name) {
	// server/zone/objects/scene/SceneObject.idl():  		return pendingTasks.contains(name);
	return (&pendingTasks)->contains(name);
}

Facade* SceneObjectImplementation::getActiveSession(unsigned int type) {
	// server/zone/objects/scene/SceneObject.idl():  		return objectActiveSessions.get(type);
	return (&objectActiveSessions)->get(type);
}

void SceneObjectImplementation::addActiveSession(unsigned int type, Facade* session) {
	// server/zone/objects/scene/SceneObject.idl():  		objectActiveSessions.put(type, session);
	(&objectActiveSessions)->put(type, session);
}

bool SceneObjectImplementation::containsActiveSession(unsigned int type) {
	// server/zone/objects/scene/SceneObject.idl():  		return objectActiveSessions.contains(type);
	return (&objectActiveSessions)->contains(type);
}

bool SceneObjectImplementation::dropActiveSession(unsigned int type) {
	// server/zone/objects/scene/SceneObject.idl():  		return objectActiveSessions.drop(type);
	return (&objectActiveSessions)->drop(type);
}

int SceneObjectImplementation::getActiveSessionsCount() {
	// server/zone/objects/scene/SceneObject.idl():  		return objectActiveSessions.size();
	return (&objectActiveSessions)->size();
}

VectorMap<unsigned int, ManagedReference<Facade* > >* SceneObjectImplementation::getObjectActiveSessions() {
	// server/zone/objects/scene/SceneObject.idl():  		return objectActiveSessions;
	return (&objectActiveSessions);
}

int SceneObjectImplementation::notifyObjectInserted(SceneObject* object) {
	// server/zone/objects/scene/SceneObject.idl():  		return 0;
	return 0;
}

int SceneObjectImplementation::notifyObjectRemoved(SceneObject* object) {
	// server/zone/objects/scene/SceneObject.idl():  		return 0;
	return 0;
}

void SceneObjectImplementation::dropActiveArea(ActiveArea* area) {
	// server/zone/objects/scene/SceneObject.idl():  		activeAreas.drop(area);
	(&activeAreas)->drop(area);
}

bool SceneObjectImplementation::hasActiveArea(ActiveArea* area) {
	// server/zone/objects/scene/SceneObject.idl():  		return activeAreas.contains(area);
	return (&activeAreas)->contains(area);
}

bool SceneObjectImplementation::hasActiveArea(unsigned long long objectid) {
	// server/zone/objects/scene/SceneObject.idl():  		}
	for (	// server/zone/objects/scene/SceneObject.idl():  		for (int i = 0;
	int i = 0;
	i < (&activeAreas)->size();
 ++i) {
	// server/zone/objects/scene/SceneObject.idl():  			ActiveArea area = activeAreas.get(i);
	ManagedReference<ActiveArea* > area = (&activeAreas)->get(i);
	// server/zone/objects/scene/SceneObject.idl():  		}
	if (area->getObjectID() == objectid){
	// server/zone/objects/scene/SceneObject.idl():  				return true;
	return true;
}
}
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

Vector<ManagedReference<ActiveArea* > >* SceneObjectImplementation::getActiveAreas() {
	// server/zone/objects/scene/SceneObject.idl():  		return activeAreas;
	return (&activeAreas);
}

int SceneObjectImplementation::getActiveAreasSize() {
	// server/zone/objects/scene/SceneObject.idl():  		return activeAreas.size();
	return (&activeAreas)->size();
}

ActiveArea* SceneObjectImplementation::getActiveRegion() {
	// server/zone/objects/scene/SceneObject.idl():  		}
	for (	// server/zone/objects/scene/SceneObject.idl():  		for (int i = 0;
	int i = 0;
	i < (&activeAreas)->size();
i ++) {
	// server/zone/objects/scene/SceneObject.idl():  			ActiveArea region = activeAreas.get(i);
	ManagedReference<ActiveArea* > region = (&activeAreas)->get(i);
	// server/zone/objects/scene/SceneObject.idl():  		}
	if (region->isRegion()){
	// server/zone/objects/scene/SceneObject.idl():  				return region;
	return region;
}
}
	// server/zone/objects/scene/SceneObject.idl():  		return null;
	return NULL;
}

ManagedWeakReference<CityRegion* > SceneObjectImplementation::getCityRegion() {
	// server/zone/objects/scene/SceneObject.idl():  		return cityRegion;
	return cityRegion;
}

void SceneObjectImplementation::setCityRegion(CityRegion* region) {
	// server/zone/objects/scene/SceneObject.idl():  		cityRegion = region;
	cityRegion = region;
}

Zone* SceneObjectImplementation::getZone() {
	// server/zone/objects/scene/SceneObject.idl():  		SceneObject strong = null;
	ManagedReference<SceneObject* > strong = NULL;
	// server/zone/objects/scene/SceneObject.idl():  		}
	if ((strong = getParent()) != NULL){
	// server/zone/objects/scene/SceneObject.idl():  			strong = getRootParent();
	strong = getRootParent();
	// server/zone/objects/scene/SceneObject.idl():  				return zone.get();
	if (strong != NULL){
	// server/zone/objects/scene/SceneObject.idl():  				return strong.getZone();
	return strong->getZone();
}

	else 	// server/zone/objects/scene/SceneObject.idl():  				return zone.get();
	return (&zone)->get();
}

	else {
	// server/zone/objects/scene/SceneObject.idl():  			return zone.get();
	return (&zone)->get();
}
}

Zone* SceneObjectImplementation::getLocalZone() {
	// server/zone/objects/scene/SceneObject.idl():  		return zone.get();
	return (&zone)->get();
}

float SceneObjectImplementation::getDirectionX() {
	// server/zone/objects/scene/SceneObject.idl():  		return direction.getX();
	return (&direction)->getX();
}

float SceneObjectImplementation::getDirectionZ() {
	// server/zone/objects/scene/SceneObject.idl():  		return direction.getZ();
	return (&direction)->getZ();
}

float SceneObjectImplementation::getDirectionY() {
	// server/zone/objects/scene/SceneObject.idl():  		return direction.getY();
	return (&direction)->getY();
}

float SceneObjectImplementation::getDirectionW() {
	// server/zone/objects/scene/SceneObject.idl():  		return direction.getW();
	return (&direction)->getW();
}

unsigned int SceneObjectImplementation::getClientObjectCRC() {
	// server/zone/objects/scene/SceneObject.idl():  		return clientObjectCRC;
	return clientObjectCRC;
}

unsigned int SceneObjectImplementation::getServerObjectCRC() {
	// server/zone/objects/scene/SceneObject.idl():  		return serverObjectCRC;
	return serverObjectCRC;
}

bool SceneObjectImplementation::isWaypointObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.WAYPOINT;
	return gameObjectType == SceneObjectType::WAYPOINT;
}

StringId* SceneObjectImplementation::getObjectName() {
	// server/zone/objects/scene/SceneObject.idl():  		return objectName;
	return (&objectName);
}

String SceneObjectImplementation::getObjectNameStringIdFile() {
	// server/zone/objects/scene/SceneObject.idl():  		return objectName.getFile();
	return (&objectName)->getFile();
}

String SceneObjectImplementation::getObjectNameStringIdName() {
	// server/zone/objects/scene/SceneObject.idl():  		return objectName.getStringID();
	return (&objectName)->getStringID();
}

String SceneObjectImplementation::getDetailedDescription() {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject.getDetailedDescription();
	return templateObject->getDetailedDescription();
}

void SceneObjectImplementation::setDetailedDescription(const String& detail) {
	// server/zone/objects/scene/SceneObject.idl():  		return;
	return;
}

int SceneObjectImplementation::getArrangementDescriptorSize() {
	// server/zone/objects/scene/SceneObject.idl():  		return 
	if (templateObject->getArrangementDescriptors() != NULL)	// server/zone/objects/scene/SceneObject.idl():  			return templateObject.getArrangementDescriptors().size();
	return templateObject->getArrangementDescriptors()->size();
	// server/zone/objects/scene/SceneObject.idl():  		return 0;
	return 0;
}

String SceneObjectImplementation::getArrangementDescriptor(int idx) {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject.getArrangementDescriptors().get(idx);
	return templateObject->getArrangementDescriptors()->get(idx);
}

String SceneObjectImplementation::getSlotDescriptor(int idx) {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject.getSlotDescriptors().get(idx);
	return templateObject->getSlotDescriptors()->get(idx);
}

bool SceneObjectImplementation::hasSlotDescriptor(const String& descr) {
	// server/zone/objects/scene/SceneObject.idl():  		}
	for (	// server/zone/objects/scene/SceneObject.idl():  		for (int i = 0;
	int i = 0;
	i < getSlotDescriptorSize();
 ++i) {
	// server/zone/objects/scene/SceneObject.idl():  		}
	if (getSlotDescriptor(i) == descr)	// server/zone/objects/scene/SceneObject.idl():  				return true;
	return true;
}
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::hasArrangementDescriptor(const String& descr) {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject.hasArrangementDescriptor(descr);
	return templateObject->hasArrangementDescriptor(descr);
}

VectorMap<String, ManagedReference<SceneObject* > >* SceneObjectImplementation::getSlottedObjects() {
	// server/zone/objects/scene/SceneObject.idl():  		return slottedObjects;
	return (&slottedObjects);
}

int SceneObjectImplementation::getSlotDescriptorSize() {
	// server/zone/objects/scene/SceneObject.idl():  		return 
	if (templateObject->getSlotDescriptors() != NULL)	// server/zone/objects/scene/SceneObject.idl():  			return templateObject.getSlotDescriptors().size();
	return templateObject->getSlotDescriptors()->size();
	// server/zone/objects/scene/SceneObject.idl():  		return 0;
	return 0;
}

int SceneObjectImplementation::getContainerObjectsSize() {
	// server/zone/objects/scene/SceneObject.idl():  		return containerObjects.size();
	return (&containerObjects)->size();
}

int SceneObjectImplementation::getSlottedObjectsSize() {
	// server/zone/objects/scene/SceneObject.idl():  		return slottedObjects.size();
	return (&slottedObjects)->size();
}

bool SceneObjectImplementation::hasFullContainerObjects() {
	// server/zone/objects/scene/SceneObject.idl():  		return containerObjects.size() > containerVolumeLimit || containerObjects.size() == containerVolumeLimit;
	return (&containerObjects)->size() > containerVolumeLimit || (&containerObjects)->size() == containerVolumeLimit;
}

unsigned int SceneObjectImplementation::getContainerVolumeLimit() {
	// server/zone/objects/scene/SceneObject.idl():  		return containerVolumeLimit;
	return containerVolumeLimit;
}

SceneObject* SceneObjectImplementation::getContainerObject(int idx) {
	// server/zone/objects/scene/SceneObject.idl():  		return containerObjects.get(idx);
	return (&containerObjects)->get(idx);
}

VectorMap<unsigned long long, ManagedReference<SceneObject* > >* SceneObjectImplementation::getContainerObjects() {
	// server/zone/objects/scene/SceneObject.idl():  		return containerObjects.getContainerObjects();
	return (&containerObjects)->getContainerObjects();
}

bool SceneObjectImplementation::hasObjectInContainer(unsigned long long objectID) {
	// server/zone/objects/scene/SceneObject.idl():  		return containerObjects.contains(objectID);
	return (&containerObjects)->contains(objectID);
}

bool SceneObjectImplementation::hasObjectInSlottedContainer(SceneObject* object) {
	// server/zone/objects/scene/SceneObject.idl():  		int arrangementSize = object.getArrangementDescriptorSize();
	int arrangementSize = object->getArrangementDescriptorSize();
	// server/zone/objects/scene/SceneObject.idl():  		SceneObject 
	if (arrangementSize == 0){
	// server/zone/objects/scene/SceneObject.idl():  			return false;
	return false;
}
	// server/zone/objects/scene/SceneObject.idl():  		SceneObject obj = null;
	ManagedReference<SceneObject* > obj = NULL;
	// server/zone/objects/scene/SceneObject.idl():  		}
{
	Locker _locker((&containerLock));
	// server/zone/objects/scene/SceneObject.idl():  			obj = slottedObjects.get(object.getArrangementDescriptor(0));
	obj = (&slottedObjects)->get(object->getArrangementDescriptor(0));
}
	// server/zone/objects/scene/SceneObject.idl():  		}
	if (object == obj){
	// server/zone/objects/scene/SceneObject.idl():  			return true;
	return true;
}

	else {
	// server/zone/objects/scene/SceneObject.idl():  			return false;
	return false;
}
}

SceneObject* SceneObjectImplementation::getContainerObject(unsigned long long objectID) {
	// server/zone/objects/scene/SceneObject.idl():  		return containerObjects.get(objectID);
	return (&containerObjects)->get(objectID);
}

void SceneObjectImplementation::removeAllContainerObjects() {
	// server/zone/objects/scene/SceneObject.idl():  		containerObjects.removeAll();
	(&containerObjects)->removeAll();
}

void SceneObjectImplementation::putInContainer(SceneObject* obj, unsigned long long key) {
	// server/zone/objects/scene/SceneObject.idl():  		containerObjects.put(key, obj);
	(&containerObjects)->put(key, obj);
}

void SceneObjectImplementation::removeFromContainerObjects(int index) {
	// server/zone/objects/scene/SceneObject.idl():  		containerObjects.removeElementAt(index);
	(&containerObjects)->removeElementAt(index);
}

void SceneObjectImplementation::setContainerVolumeLimit(int lim) {
	// server/zone/objects/scene/SceneObject.idl():  		containerVolumeLimit = lim;
	containerVolumeLimit = lim;
}

void SceneObjectImplementation::setContainerType(int type) {
	// server/zone/objects/scene/SceneObject.idl():  		containerType = type;
	containerType = type;
}

unsigned int SceneObjectImplementation::getContainerType() {
	// server/zone/objects/scene/SceneObject.idl():  		return containerType;
	return containerType;
}

ZoneClientSession* SceneObjectImplementation::getClient() {
	// server/zone/objects/scene/SceneObject.idl():  		return null;
	return NULL;
}

unsigned int SceneObjectImplementation::getGameObjectType() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType;
	return gameObjectType;
}

unsigned int SceneObjectImplementation::getClientGameObjectType() {
	// server/zone/objects/scene/SceneObject.idl():  		return clientGameObjectType;
	return clientGameObjectType;
}

unsigned int SceneObjectImplementation::getContainmentType() {
	// server/zone/objects/scene/SceneObject.idl():  		return containmentType;
	return containmentType;
}

float SceneObjectImplementation::getDirectionAngle() {
	// server/zone/objects/scene/SceneObject.idl():  		return direction.getDegrees();
	return (&direction)->getDegrees();
}

float SceneObjectImplementation::getSpecialDirectionAngle() {
	// server/zone/objects/scene/SceneObject.idl():  		return direction.getSpecialDegrees();
	return (&direction)->getSpecialDegrees();
}

unsigned int SceneObjectImplementation::getMovementCounter() {
	// server/zone/objects/scene/SceneObject.idl():  		return movementCounter;
	return movementCounter;
}

ZoneServer* SceneObjectImplementation::getZoneServer() {
	// server/zone/objects/scene/SceneObject.idl():  			return null;
	if (server != NULL)	// server/zone/objects/scene/SceneObject.idl():  			return server.getZoneServer();
	return server->getZoneServer();

	else 	// server/zone/objects/scene/SceneObject.idl():  			return null;
	return NULL;
}

ReadWriteLock* SceneObjectImplementation::getContainerLock() {
	// server/zone/objects/scene/SceneObject.idl():  		return containerLock;
	return (&containerLock);
}

UnicodeString SceneObjectImplementation::getCustomObjectName() {
	// server/zone/objects/scene/SceneObject.idl():  		return customName;
	return customName;
}

String SceneObjectImplementation::getLoggingName() {
	// server/zone/objects/scene/SceneObject.idl():  		return Logger.getLoggingName();
	return Logger::getLoggingName();
}

bool SceneObjectImplementation::isPlayerCreature() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isVendor() {
	// server/zone/objects/scene/SceneObject.idl():  		dataObjectComponent.get().isVendorData();
	return (&dataObjectComponent) != NULL && (&dataObjectComponent)->get() != NULL && (&dataObjectComponent)->get()->isVendorData();
}

ZoneComponent* SceneObjectImplementation::getZoneComponent() {
	// server/zone/objects/scene/SceneObject.idl():  		return zoneComponent;
	return zoneComponent;
}

ObjectMenuComponent* SceneObjectImplementation::getObjectMenuComponent() {
	// server/zone/objects/scene/SceneObject.idl():  		return objectMenuComponent;
	return objectMenuComponent;
}

DataObjectComponentReference* SceneObjectImplementation::getDataObjectComponent() {
	// server/zone/objects/scene/SceneObject.idl():  		return dataObjectComponent;
	return (&dataObjectComponent);
}

bool SceneObjectImplementation::isNoTrade() {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject.isNoTrade();
	return templateObject->isNoTrade();
}

bool SceneObjectImplementation::isContainerFull() {
	// server/zone/objects/scene/SceneObject.idl():  		return containerVolumeLimit <= containerObjects.size();
	return containerVolumeLimit <= (&containerObjects)->size();
}

bool SceneObjectImplementation::isShuttleInstallation() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.SHUTTLEINSTALLATION;
	return gameObjectType == SceneObjectType::SHUTTLEINSTALLATION;
}

bool SceneObjectImplementation::isPlayerObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.PLAYEROBJECT;
	return gameObjectType == SceneObjectType::PLAYEROBJECT;
}

bool SceneObjectImplementation::isActiveArea() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isRegion() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isCreatureObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isAiAgent() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isShipObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isVehicleObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isBuildingObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isCloningBuildingObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isGarage() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.GARAGEBUILDING || gameObjectType == SceneObjectType.GARAGEINSTALLATION;
	return gameObjectType == SceneObjectType::GARAGEBUILDING || gameObjectType == SceneObjectType::GARAGEINSTALLATION;
}

bool SceneObjectImplementation::isWeaponObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isWearableObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isArmorObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isRobeObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isLightsaberCrystalObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isFireworkObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isPsgArmorObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.SHIELDGENERATOR;
	return gameObjectType == SceneObjectType::SHIELDGENERATOR;
}

bool SceneObjectImplementation::isCellObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isTangibleObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isResourceContainer() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isResourceSpawn() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isComponent() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isIntangibleObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isInstrument() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.INSTRUMENT;
	return gameObjectType == SceneObjectType::INSTRUMENT;
}

bool SceneObjectImplementation::isBazaarTerminal() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.BAZAAR;
	return gameObjectType == SceneObjectType::BAZAAR;
}

bool SceneObjectImplementation::isLiveSample() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.LIVESAMPLE;
	return gameObjectType == SceneObjectType::LIVESAMPLE;
}

bool SceneObjectImplementation::isInstallationObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isHarvesterObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isGeneratorObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isCityTerminal() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isCityVoteTerminal() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isFactory() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isFactoryCrate() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isFishingPoleObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.FISHINGPOLE;
	return gameObjectType == SceneObjectType::FISHINGPOLE;
}

bool SceneObjectImplementation::isDeedObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isVehicleDeedObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isBuildingDeed() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isSignObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isInstallationDeed() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isCraftingTool() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isCraftingStation() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isManufactureSchematic() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isStructureObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isAuctionObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isFishingBait() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.FISHINGBAIT;
	return gameObjectType == SceneObjectType::FISHINGBAIT;
}

bool SceneObjectImplementation::isTrapObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.TRAP;
	return gameObjectType == SceneObjectType::TRAP;
}

bool SceneObjectImplementation::isRepairTool() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.REPAIRTOOL;
	return gameObjectType == SceneObjectType::REPAIRTOOL;
}

bool SceneObjectImplementation::isCamoKit() {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject.isCamoKitTemplate();
	return templateObject->isCamoKitTemplate();
}

bool SceneObjectImplementation::isAttachment() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isDiceObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject.isDiceTemplate();
	return templateObject->isDiceTemplate();
}

bool SceneObjectImplementation::isCreatureHabitat() {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject.isCreatureHabitatTemplate();
	return templateObject->isCreatureHabitatTemplate();
}

bool SceneObjectImplementation::isCampKit() {
	// server/zone/objects/scene/SceneObject.idl():  		return gameObjectType == SceneObjectType.CAMPKIT;
	return gameObjectType == SceneObjectType::CAMPKIT;
}

bool SceneObjectImplementation::isCampStructure() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

ContainerPermissions* SceneObjectImplementation::getContainerPermissions() {
	// server/zone/objects/scene/SceneObject.idl():  		return containerPermissions;
	return (&containerPermissions);
}

void SceneObjectImplementation::setContainerDefaultAllowPermission(unsigned short perm) {
	// server/zone/objects/scene/SceneObject.idl():  		containerPermissions.setDefaultAllowPermission(perm);
	(&containerPermissions)->setDefaultAllowPermission(perm);
}

void SceneObjectImplementation::clearContainerDefaultAllowPermission(unsigned short perm) {
	// server/zone/objects/scene/SceneObject.idl():  		containerPermissions.clearDefaultAllowPermission(perm);
	(&containerPermissions)->clearDefaultAllowPermission(perm);
}

void SceneObjectImplementation::setContainerDefaultDenyPermission(unsigned short perm) {
	// server/zone/objects/scene/SceneObject.idl():  		containerPermissions.setDefaultDenyPermission(perm);
	(&containerPermissions)->setDefaultDenyPermission(perm);
}

void SceneObjectImplementation::clearContainerDefaultDenyPermission(unsigned short perm) {
	// server/zone/objects/scene/SceneObject.idl():  		containerPermissions.clearDefaultDenyPermission(perm);
	(&containerPermissions)->clearDefaultDenyPermission(perm);
}

void SceneObjectImplementation::setContainerInheritPermissionsFromParent(bool val) {
	// server/zone/objects/scene/SceneObject.idl():  		containerPermissions.setInheritPermissionsFromParent(val);
	(&containerPermissions)->setInheritPermissionsFromParent(val);
}

void SceneObjectImplementation::setContainerOwnerID(unsigned long long id) {
	// server/zone/objects/scene/SceneObject.idl():  		containerPermissions.setOwner(id);
	(&containerPermissions)->setOwner(id);
}

void SceneObjectImplementation::setContainerAllowPermission(const String& group, unsigned short perm) {
	// server/zone/objects/scene/SceneObject.idl():  		containerPermissions.setAllowPermission(group, perm);
	(&containerPermissions)->setAllowPermission(group, perm);
}

void SceneObjectImplementation::setContainerDenyPermission(const String& group, unsigned short perm) {
	// server/zone/objects/scene/SceneObject.idl():  		containerPermissions.setDenyPermission(group, perm);
	(&containerPermissions)->setDenyPermission(group, perm);
}

void SceneObjectImplementation::setGameObjectType(unsigned int type) {
	// server/zone/objects/scene/SceneObject.idl():  		gameObjectType = type;
	gameObjectType = type;
}

void SceneObjectImplementation::setClientObjectCRC(unsigned int objCRC) {
	// server/zone/objects/scene/SceneObject.idl():  		clientObjectCRC = objCRC;
	clientObjectCRC = objCRC;
}

void SceneObjectImplementation::setServerObjectCRC(unsigned int objCRC) {
	// server/zone/objects/scene/SceneObject.idl():  		serverObjectCRC = objCRC;
	serverObjectCRC = objCRC;
}

void SceneObjectImplementation::setZoneProcessServer(ZoneProcessServer* srv) {
	// server/zone/objects/scene/SceneObject.idl():  		server = srv;
	server = srv;
}

ZoneProcessServer* SceneObjectImplementation::getZoneProcessServer() {
	// server/zone/objects/scene/SceneObject.idl():  		return server;
	return server;
}

void SceneObjectImplementation::setDirection(float fw, float fx, float fy, float fz) {
	// server/zone/objects/scene/SceneObject.idl():  		direction.set(fw, fx, fy, fz);
	(&direction)->set(fw, fx, fy, fz);
}

void SceneObjectImplementation::setDirection(float headingAngleRadians) {
	// server/zone/objects/scene/SceneObject.idl():  		direction.setHeadingDirection(headingAngleRadians);
	(&direction)->setHeadingDirection(headingAngleRadians);
}

void SceneObjectImplementation::setMovementCounter(unsigned int count) {
	// server/zone/objects/scene/SceneObject.idl():  		movementCounter = count;
	movementCounter = count;
}

void SceneObjectImplementation::incrementMovementCounter() {
	// server/zone/objects/scene/SceneObject.idl():  		movementCounter++;
	movementCounter ++;
}

void SceneObjectImplementation::setContainmentType(unsigned int type) {
	// server/zone/objects/scene/SceneObject.idl():  		containmentType = type;
	containmentType = type;
}

void SceneObjectImplementation::setLoggingName(const String& name) {
	// server/zone/objects/scene/SceneObject.idl():  		Logger.setLoggingName(name);
	Logger::setLoggingName(name);
}

void SceneObjectImplementation::setClientObject(bool val) {
	// server/zone/objects/scene/SceneObject.idl():  		staticObject = val;
	staticObject = val;
}

bool SceneObjectImplementation::isStaticObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return staticObject;
	return staticObject;
}

bool SceneObjectImplementation::isContainerObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isTerminal() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isGroupObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isGuildObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isControlDevice() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isMissionTerminal() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isMissionObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

bool SceneObjectImplementation::isActorObject() {
	// server/zone/objects/scene/SceneObject.idl():  		return false;
	return false;
}

int SceneObjectImplementation::getPlanetMapCategoryCRC() {
	// server/zone/objects/scene/SceneObject.idl():  		return planetMapCategory;
	return planetMapCategory;
}

int SceneObjectImplementation::getPlanetMapSubCategoryCRC() {
	// server/zone/objects/scene/SceneObject.idl():  		return planetMapSubCategory;
	return planetMapSubCategory;
}

void SceneObjectImplementation::setPlanetMapCategory(PlanetMapCategory* pmc) {
	// server/zone/objects/scene/SceneObject.idl():  			planetMapCategory = pmc.getCrc();
	if (pmc == NULL)	// server/zone/objects/scene/SceneObject.idl():  			planetMapCategory = 0;
	planetMapCategory = 0;

	else 	// server/zone/objects/scene/SceneObject.idl():  			planetMapCategory = pmc.getCrc();
	planetMapCategory = pmc->getCrc();
}

void SceneObjectImplementation::setPlanetMapSubCategory(PlanetMapCategory* pmc) {
	// server/zone/objects/scene/SceneObject.idl():  		planetMapSubCategory = pmc.getCrc();
	planetMapSubCategory = pmc->getCrc();
}

PlanetMapCategory* SceneObjectImplementation::getPlanetMapCategory() {
	// server/zone/objects/scene/SceneObject.idl():  		TemplateManager templateManager = TemplateManager.instance();
	TemplateManager* templateManager = TemplateManager::instance();
	// server/zone/objects/scene/SceneObject.idl():  		return templateManager.getPlanetMapCategoryByCrc(planetMapCategory);
	return templateManager->getPlanetMapCategoryByCrc(planetMapCategory);
}

PlanetMapCategory* SceneObjectImplementation::getPlanetMapSubCategory() {
	// server/zone/objects/scene/SceneObject.idl():  		TemplateManager templateManager = TemplateManager.instance();
	TemplateManager* templateManager = TemplateManager::instance();
	// server/zone/objects/scene/SceneObject.idl():  		return templateManager.getPlanetMapCategoryByCrc(planetMapSubCategory);
	return templateManager->getPlanetMapCategoryByCrc(planetMapSubCategory);
}

SortedVector<ManagedReference<SceneObject* > >* SceneObjectImplementation::getChildObjects() {
	// server/zone/objects/scene/SceneObject.idl():  		return childObjects;
	return (&childObjects);
}

bool SceneObjectImplementation::containsChildObject(SceneObject* obj) {
	// server/zone/objects/scene/SceneObject.idl():  		return childObjects.contains(obj);
	return (&childObjects)->contains(obj);
}

SharedObjectTemplate* SceneObjectImplementation::getObjectTemplate() {
	// server/zone/objects/scene/SceneObject.idl():  		return templateObject;
	return templateObject;
}

Matrix4* SceneObjectImplementation::getTransformForCollisionMatrix() {
	// server/zone/objects/scene/SceneObject.idl():  		return transformForCollisionMatrix;
	return transformForCollisionMatrix;
}

bool SceneObjectImplementation::doSendToClient() {
	// server/zone/objects/scene/SceneObject.idl():  		return sendToClient;
	return sendToClient;
}

void SceneObjectImplementation::setSendToClient(bool val) {
	// server/zone/objects/scene/SceneObject.idl():  		sendToClient = val;
	sendToClient = val;
}

/*
 *	SceneObjectAdapter
 */


#include "engine/orb/messages/InvokeMethodMessage.h"


SceneObjectAdapter::SceneObjectAdapter(SceneObject* obj) : QuadTreeEntryAdapter(obj) {
}

void SceneObjectAdapter::invokeMethod(uint32 methid, DistributedMethod* inv) {
	DOBMessage* resp = inv->getInvocationMessage();

	switch (methid) {
	case RPC_FINALIZE__:
		{
			finalize();
		}
		break;
	case RPC_INITIALIZEPRIVATEDATA__:
		{
			initializePrivateData();
		}
		break;
	case RPC_CREATECOMPONENTS__:
		{
			createComponents();
		}
		break;
	case RPC_CREATECONTAINERCOMPONENT__:
		{
			createContainerComponent();
		}
		break;
	case RPC_INITIALIZETRANSIENTMEMBERS__:
		{
			initializeTransientMembers();
		}
		break;
	case RPC_NOTIFYLOADFROMDATABASE__:
		{
			notifyLoadFromDatabase();
		}
		break;
	case RPC_INFO__STRING_BOOL_:
		{
			String msg; 
			info(inv->getAsciiParameter(msg), inv->getBooleanParameter());
		}
		break;
	case RPC_ERROR__STRING_:
		{
			String msg; 
			error(inv->getAsciiParameter(msg));
		}
		break;
	case RPC_INRANGEOBJECTS__INT_FLOAT_:
		{
			resp->insertSignedInt(inRangeObjects(inv->getUnsignedIntParameter(), inv->getFloatParameter()));
		}
		break;
	case RPC_ISINRANGE__SCENEOBJECT_FLOAT_:
		{
			resp->insertBoolean(isInRange(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getFloatParameter()));
		}
		break;
	case RPC_TRANSFEROBJECT__SCENEOBJECT_INT_BOOL_:
		{
			resp->insertBoolean(transferObject(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getSignedIntParameter(), inv->getBooleanParameter()));
		}
		break;
	case RPC_REMOVEOBJECT__SCENEOBJECT_SCENEOBJECT_BOOL_:
		{
			resp->insertBoolean(removeObject(static_cast<SceneObject*>(inv->getObjectParameter()), static_cast<SceneObject*>(inv->getObjectParameter()), inv->getBooleanParameter()));
		}
		break;
	case RPC_DESTROYOBJECTFROMWORLD__BOOL_:
		{
			destroyObjectFromWorld(inv->getBooleanParameter());
		}
		break;
	case RPC_CANADDOBJECT__SCENEOBJECT_INT_STRING_:
		{
			String errorDescription; 
			resp->insertSignedInt(canAddObject(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getSignedIntParameter(), inv->getAsciiParameter(errorDescription)));
		}
		break;
	case RPC_NOTIFYOBJECTINSERTEDTOCHILD__SCENEOBJECT_SCENEOBJECT_SCENEOBJECT_:
		{
			resp->insertSignedInt(notifyObjectInsertedToChild(static_cast<SceneObject*>(inv->getObjectParameter()), static_cast<SceneObject*>(inv->getObjectParameter()), static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_NOTIFYOBJECTREMOVEDFROMCHILD__SCENEOBJECT_SCENEOBJECT_:
		{
			resp->insertSignedInt(notifyObjectRemovedFromChild(static_cast<SceneObject*>(inv->getObjectParameter()), static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_SYNCHRONIZEDUILISTEN__SCENEOBJECT_INT_:
		{
			synchronizedUIListen(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getSignedIntParameter());
		}
		break;
	case RPC_SYNCHRONIZEDUISTOPLISTEN__SCENEOBJECT_INT_:
		{
			synchronizedUIStopListen(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getSignedIntParameter());
		}
		break;
	case RPC_UPDATETODATABASE__:
		{
			updateToDatabase();
		}
		break;
	case RPC_UPDATETODATABASEWITHOUTCHILDREN__:
		{
			updateToDatabaseWithoutChildren();
		}
		break;
	case RPC_UPDATETODATABASEALLOBJECTS__BOOL_:
		{
			updateToDatabaseAllObjects(inv->getBooleanParameter());
		}
		break;
	case RPC_DESTROYPLAYERCREATUREFROMDATABASE__BOOL_:
		{
			destroyPlayerCreatureFromDatabase(inv->getBooleanParameter());
		}
		break;
	case RPC_DESTROYOBJECTFROMDATABASE__BOOL_:
		{
			destroyObjectFromDatabase(inv->getBooleanParameter());
		}
		break;
	case RPC_CANBEDESTROYED__CREATUREOBJECT_:
		{
			resp->insertSignedInt(canBeDestroyed(static_cast<CreatureObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_LINK__LONG_INT_:
		{
			resp->insertLong(link(inv->getUnsignedLongParameter(), inv->getUnsignedIntParameter())->_getObjectID());
		}
		break;
	case RPC_SENDTO__SCENEOBJECT_BOOL_:
		{
			sendTo(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getBooleanParameter());
		}
		break;
	case RPC_SENDWITHOUTPARENTTO__SCENEOBJECT_:
		{
			sendWithoutParentTo(static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SENDWITHOUTCONTAINEROBJECTSTO__SCENEOBJECT_:
		{
			sendWithoutContainerObjectsTo(static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SENDDESTROYTO__SCENEOBJECT_:
		{
			sendDestroyTo(static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SENDBASELINESTO__SCENEOBJECT_:
		{
			sendBaselinesTo(static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SENDCONTAINEROBJECTSTO__SCENEOBJECT_:
		{
			sendContainerObjectsTo(static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SENDSLOTTEDOBJECTSTO__SCENEOBJECT_:
		{
			sendSlottedObjectsTo(static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SENDTOOWNER__BOOL_:
		{
			sendToOwner(inv->getBooleanParameter());
		}
		break;
	case RPC_SENDATTRIBUTELISTTO__CREATUREOBJECT_:
		{
			sendAttributeListTo(static_cast<CreatureObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SETCUSTOMOBJECTNAME__UNICODESTRING_BOOL_:
		{
			UnicodeString name; 
			setCustomObjectName(inv->getUnicodeParameter(name), inv->getBooleanParameter());
		}
		break;
	case RPC_OPENCONTAINERTO__CREATUREOBJECT_:
		{
			openContainerTo(static_cast<CreatureObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_CLOSECONTAINERTO__CREATUREOBJECT_BOOL_:
		{
			closeContainerTo(static_cast<CreatureObject*>(inv->getObjectParameter()), inv->getBooleanParameter());
		}
		break;
	case RPC_NOTIFYINSERTTOZONE__ZONE_:
		{
			notifyInsertToZone(static_cast<Zone*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SWITCHZONE__STRING_FLOAT_FLOAT_FLOAT_LONG_:
		{
			String newTerrainName; 
			switchZone(inv->getAsciiParameter(newTerrainName), inv->getFloatParameter(), inv->getFloatParameter(), inv->getFloatParameter(), inv->getUnsignedLongParameter());
		}
		break;
	case RPC_TELEPORT__FLOAT_FLOAT_FLOAT_LONG_:
		{
			teleport(inv->getFloatParameter(), inv->getFloatParameter(), inv->getFloatParameter(), inv->getUnsignedLongParameter());
		}
		break;
	case RPC_UPDATEDIRECTION__FLOAT_FLOAT_FLOAT_FLOAT_:
		{
			updateDirection(inv->getFloatParameter(), inv->getFloatParameter(), inv->getFloatParameter(), inv->getFloatParameter());
		}
		break;
	case RPC_UPDATEDIRECTION__FLOAT_:
		{
			updateDirection(inv->getFloatParameter());
		}
		break;
	case RPC_NOTIFYREMOVEFROMZONE__:
		{
			notifyRemoveFromZone();
		}
		break;
	case RPC_UPDATEZONE__BOOL_BOOL_:
		{
			updateZone(inv->getBooleanParameter(), inv->getBooleanParameter());
		}
		break;
	case RPC_UPDATEZONEWITHPARENT__SCENEOBJECT_BOOL_BOOL_:
		{
			updateZoneWithParent(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getBooleanParameter(), inv->getBooleanParameter());
		}
		break;
	case RPC_BROADCASTMESSAGE__BASEPACKET_BOOL_BOOL_:
		{
			broadcastMessage(static_cast<BasePacket*>(inv->getObjectParameter()), inv->getBooleanParameter(), inv->getBooleanParameter());
		}
		break;
	case RPC_BROADCASTMESSAGEPRIVATE__BASEPACKET_SCENEOBJECT_BOOL_:
		{
			broadcastMessagePrivate(static_cast<BasePacket*>(inv->getObjectParameter()), static_cast<SceneObject*>(inv->getObjectParameter()), inv->getBooleanParameter());
		}
		break;
	case RPC_BROADCASTOBJECT__SCENEOBJECT_BOOL_:
		{
			broadcastObject(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getBooleanParameter());
		}
		break;
	case RPC_BROADCASTOBJECTPRIVATE__SCENEOBJECT_SCENEOBJECT_:
		{
			broadcastObjectPrivate(static_cast<SceneObject*>(inv->getObjectParameter()), static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_BROADCASTDESTROY__SCENEOBJECT_BOOL_:
		{
			broadcastDestroy(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getBooleanParameter());
		}
		break;
	case RPC_BROADCASTDESTROYPRIVATE__SCENEOBJECT_SCENEOBJECT_:
		{
			broadcastDestroyPrivate(static_cast<SceneObject*>(inv->getObjectParameter()), static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SENDMESSAGE__BASEPACKET_:
		{
			sendMessage(static_cast<BasePacket*>(inv->getObjectParameter()));
		}
		break;
	case RPC_COMPARETO__SCENEOBJECT_:
		{
			resp->insertSignedInt(compareTo(static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_GETPARENTID__:
		{
			resp->insertLong(getParentID());
		}
		break;
	case RPC_CONTAINSPENDINGTASK__STRING_:
		{
			String name; 
			resp->insertBoolean(containsPendingTask(inv->getAsciiParameter(name)));
		}
		break;
	case RPC_SHOWFLYTEXT__STRING_STRING_BYTE_BYTE_BYTE_:
		{
			String file; String uax; 
			showFlyText(inv->getAsciiParameter(file), inv->getAsciiParameter(uax), inv->getByteParameter(), inv->getByteParameter(), inv->getByteParameter());
		}
		break;
	case RPC_GETCONTAINEDOBJECTSRECURSIVE__:
		{
			resp->insertSignedInt(getContainedObjectsRecursive());
		}
		break;
	case RPC_GETACTIVESESSION__INT_:
		{
			resp->insertLong(getActiveSession(inv->getUnsignedIntParameter())->_getObjectID());
		}
		break;
	case RPC_ADDACTIVESESSION__INT_FACADE_:
		{
			addActiveSession(inv->getUnsignedIntParameter(), static_cast<Facade*>(inv->getObjectParameter()));
		}
		break;
	case RPC_CONTAINSACTIVESESSION__INT_:
		{
			resp->insertBoolean(containsActiveSession(inv->getUnsignedIntParameter()));
		}
		break;
	case RPC_DROPACTIVESESSION__INT_:
		{
			resp->insertBoolean(dropActiveSession(inv->getUnsignedIntParameter()));
		}
		break;
	case RPC_GETACTIVESESSIONSCOUNT__:
		{
			resp->insertSignedInt(getActiveSessionsCount());
		}
		break;
	case RPC_HANDLEOBJECTMENUSELECT__CREATUREOBJECT_BYTE_:
		{
			resp->insertSignedInt(handleObjectMenuSelect(static_cast<CreatureObject*>(inv->getObjectParameter()), inv->getByteParameter()));
		}
		break;
	case RPC_GETDISTANCETO__SCENEOBJECT_:
		{
			resp->insertFloat(getDistanceTo(static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_UPDATEVEHICLEPOSITION__BOOL_:
		{
			updateVehiclePosition(inv->getBooleanParameter());
		}
		break;
	case RPC_NOTIFYOBJECTINSERTED__SCENEOBJECT_:
		{
			resp->insertSignedInt(notifyObjectInserted(static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_NOTIFYOBJECTREMOVED__SCENEOBJECT_:
		{
			resp->insertSignedInt(notifyObjectRemoved(static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_ADDACTIVEAREA__ACTIVEAREA_:
		{
			addActiveArea(static_cast<ActiveArea*>(inv->getObjectParameter()));
		}
		break;
	case RPC_DROPACTIVEAREA__ACTIVEAREA_:
		{
			dropActiveArea(static_cast<ActiveArea*>(inv->getObjectParameter()));
		}
		break;
	case RPC_HASACTIVEAREA__ACTIVEAREA_:
		{
			resp->insertBoolean(hasActiveArea(static_cast<ActiveArea*>(inv->getObjectParameter())));
		}
		break;
	case RPC_HASACTIVEAREA__LONG_:
		{
			resp->insertBoolean(hasActiveArea(inv->getUnsignedLongParameter()));
		}
		break;
	case RPC_GETACTIVEAREASSIZE__:
		{
			resp->insertSignedInt(getActiveAreasSize());
		}
		break;
	case RPC_GETACTIVEREGION__:
		{
			resp->insertLong(getActiveRegion()->_getObjectID());
		}
		break;
	case RPC_GETZONE__:
		{
			resp->insertLong(getZone()->_getObjectID());
		}
		break;
	case RPC_GETLOCALZONE__:
		{
			resp->insertLong(getLocalZone()->_getObjectID());
		}
		break;
	case RPC_GETOBJECTID__:
		{
			resp->insertLong(getObjectID());
		}
		break;
	case RPC_GETWORLDPOSITIONX__:
		{
			resp->insertFloat(getWorldPositionX());
		}
		break;
	case RPC_GETWORLDPOSITIONY__:
		{
			resp->insertFloat(getWorldPositionY());
		}
		break;
	case RPC_GETWORLDPOSITIONZ__:
		{
			resp->insertFloat(getWorldPositionZ());
		}
		break;
	case RPC_GETDIRECTIONX__:
		{
			resp->insertFloat(getDirectionX());
		}
		break;
	case RPC_GETDIRECTIONZ__:
		{
			resp->insertFloat(getDirectionZ());
		}
		break;
	case RPC_GETDIRECTIONY__:
		{
			resp->insertFloat(getDirectionY());
		}
		break;
	case RPC_GETDIRECTIONW__:
		{
			resp->insertFloat(getDirectionW());
		}
		break;
	case RPC_GETCLIENTOBJECTCRC__:
		{
			resp->insertInt(getClientObjectCRC());
		}
		break;
	case RPC_GETSERVEROBJECTCRC__:
		{
			resp->insertInt(getServerObjectCRC());
		}
		break;
	case RPC_ISWAYPOINTOBJECT__:
		{
			resp->insertBoolean(isWaypointObject());
		}
		break;
	case RPC_GETOBJECTNAMESTRINGIDFILE__:
		{
			resp->insertAscii(getObjectNameStringIdFile());
		}
		break;
	case RPC_GETOBJECTNAMESTRINGIDNAME__:
		{
			resp->insertAscii(getObjectNameStringIdName());
		}
		break;
	case RPC_SETDETAILEDDESCRIPTION__STRING_:
		{
			String detail; 
			setDetailedDescription(inv->getAsciiParameter(detail));
		}
		break;
	case RPC_GETARRANGEMENTDESCRIPTORSIZE__:
		{
			resp->insertSignedInt(getArrangementDescriptorSize());
		}
		break;
	case RPC_GETARRANGEMENTDESCRIPTOR__INT_:
		{
			resp->insertAscii(getArrangementDescriptor(inv->getSignedIntParameter()));
		}
		break;
	case RPC_GETSLOTDESCRIPTOR__INT_:
		{
			resp->insertAscii(getSlotDescriptor(inv->getSignedIntParameter()));
		}
		break;
	case RPC_HASSLOTDESCRIPTOR__STRING_:
		{
			String descr; 
			resp->insertBoolean(hasSlotDescriptor(inv->getAsciiParameter(descr)));
		}
		break;
	case RPC_HASARRANGEMENTDESCRIPTOR__STRING_:
		{
			String descr; 
			resp->insertBoolean(hasArrangementDescriptor(inv->getAsciiParameter(descr)));
		}
		break;
	case RPC_GETSLOTTEDOBJECT__STRING_:
		{
			String slot; 
			resp->insertLong(getSlottedObject(inv->getAsciiParameter(slot))->_getObjectID());
		}
		break;
	case RPC_GETSLOTDESCRIPTORSIZE__:
		{
			resp->insertSignedInt(getSlotDescriptorSize());
		}
		break;
	case RPC_GETSLOTTEDOBJECT__INT_:
		{
			resp->insertLong(getSlottedObject(inv->getSignedIntParameter())->_getObjectID());
		}
		break;
	case RPC_DROPSLOTTEDOBJECT__STRING_:
		{
			String arrengementDescriptor; 
			dropSlottedObject(inv->getAsciiParameter(arrengementDescriptor));
		}
		break;
	case RPC_REMOVESLOTTEDOBJECT__INT_:
		{
			removeSlottedObject(inv->getSignedIntParameter());
		}
		break;
	case RPC_GETCONTAINEROBJECTSSIZE__:
		{
			resp->insertSignedInt(getContainerObjectsSize());
		}
		break;
	case RPC_GETSLOTTEDOBJECTSSIZE__:
		{
			resp->insertSignedInt(getSlottedObjectsSize());
		}
		break;
	case RPC_HASFULLCONTAINEROBJECTS__:
		{
			resp->insertBoolean(hasFullContainerObjects());
		}
		break;
	case RPC_GETCONTAINERVOLUMELIMIT__:
		{
			resp->insertInt(getContainerVolumeLimit());
		}
		break;
	case RPC_GETCONTAINEROBJECT__INT_:
		{
			resp->insertLong(getContainerObject(inv->getSignedIntParameter())->_getObjectID());
		}
		break;
	case RPC_HASOBJECTINCONTAINER__LONG_:
		{
			resp->insertBoolean(hasObjectInContainer(inv->getUnsignedLongParameter()));
		}
		break;
	case RPC_HASOBJECTINSLOTTEDCONTAINER__SCENEOBJECT_:
		{
			resp->insertBoolean(hasObjectInSlottedContainer(static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_GETCONTAINEROBJECT__LONG_:
		{
			resp->insertLong(getContainerObject(inv->getUnsignedLongParameter())->_getObjectID());
		}
		break;
	case RPC_REMOVEALLCONTAINEROBJECTS__:
		{
			removeAllContainerObjects();
		}
		break;
	case RPC_PUTINCONTAINER__SCENEOBJECT_LONG_:
		{
			putInContainer(static_cast<SceneObject*>(inv->getObjectParameter()), inv->getUnsignedLongParameter());
		}
		break;
	case RPC_REMOVEFROMCONTAINEROBJECTS__INT_:
		{
			removeFromContainerObjects(inv->getSignedIntParameter());
		}
		break;
	case RPC_SETCONTAINERVOLUMELIMIT__INT_:
		{
			setContainerVolumeLimit(inv->getSignedIntParameter());
		}
		break;
	case RPC_SETCONTAINERTYPE__INT_:
		{
			setContainerType(inv->getSignedIntParameter());
		}
		break;
	case RPC_GETCONTAINERTYPE__:
		{
			resp->insertInt(getContainerType());
		}
		break;
	case RPC_GETCLIENT__:
		{
			resp->insertLong(getClient()->_getObjectID());
		}
		break;
	case RPC_GETGAMEOBJECTTYPE__:
		{
			resp->insertInt(getGameObjectType());
		}
		break;
	case RPC_GETCLIENTGAMEOBJECTTYPE__:
		{
			resp->insertInt(getClientGameObjectType());
		}
		break;
	case RPC_GETCONTAINMENTTYPE__:
		{
			resp->insertInt(getContainmentType());
		}
		break;
	case RPC_GETDIRECTIONANGLE__:
		{
			resp->insertFloat(getDirectionAngle());
		}
		break;
	case RPC_GETSPECIALDIRECTIONANGLE__:
		{
			resp->insertFloat(getSpecialDirectionAngle());
		}
		break;
	case RPC_ROTATE__INT_:
		{
			rotate(inv->getSignedIntParameter());
		}
		break;
	case RPC_FACEOBJECT__SCENEOBJECT_:
		{
			faceObject(static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_NOTIFYSELFPOSITIONUPDATE__:
		{
			notifySelfPositionUpdate();
		}
		break;
	case RPC_NOTIFYPOSITIONUPDATE__QUADTREEENTRY_:
		{
			notifyPositionUpdate(static_cast<QuadTreeEntry*>(inv->getObjectParameter()));
		}
		break;
	case RPC_NOTIFYCLOSECONTAINER__CREATUREOBJECT_:
		{
			notifyCloseContainer(static_cast<CreatureObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_GETMOVEMENTCOUNTER__:
		{
			resp->insertInt(getMovementCounter());
		}
		break;
	case RPC_GETPARENT__:
		{
			resp->insertLong(getParent().get()->_getObjectID());
		}
		break;
	case RPC_GETZONESERVER__:
		{
			resp->insertLong(getZoneServer()->_getObjectID());
		}
		break;
	case RPC_GETROOTPARENT__:
		{
			resp->insertLong(getRootParent().get()->_getObjectID());
		}
		break;
	case RPC_GETPARENTRECURSIVELY__INT_:
		{
			resp->insertLong(getParentRecursively(inv->getUnsignedIntParameter()).get()->_getObjectID());
		}
		break;
	case RPC_ISASUBCHILDOF__SCENEOBJECT_:
		{
			resp->insertBoolean(isASubChildOf(static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_GETCUSTOMOBJECTNAME__:
		{
			resp->insertUnicode(getCustomObjectName());
		}
		break;
	case RPC_GETLOGGINGNAME__:
		{
			resp->insertAscii(getLoggingName());
		}
		break;
	case RPC_ISPLAYERCREATURE__:
		{
			resp->insertBoolean(isPlayerCreature());
		}
		break;
	case RPC_ISNOTRADE__:
		{
			resp->insertBoolean(isNoTrade());
		}
		break;
	case RPC_ISCONTAINERFULL__:
		{
			resp->insertBoolean(isContainerFull());
		}
		break;
	case RPC_ISSHUTTLEINSTALLATION__:
		{
			resp->insertBoolean(isShuttleInstallation());
		}
		break;
	case RPC_ISPLAYEROBJECT__:
		{
			resp->insertBoolean(isPlayerObject());
		}
		break;
	case RPC_ISACTIVEAREA__:
		{
			resp->insertBoolean(isActiveArea());
		}
		break;
	case RPC_ISREGION__:
		{
			resp->insertBoolean(isRegion());
		}
		break;
	case RPC_ISCREATUREOBJECT__:
		{
			resp->insertBoolean(isCreatureObject());
		}
		break;
	case RPC_ISAIAGENT__:
		{
			resp->insertBoolean(isAiAgent());
		}
		break;
	case RPC_ISSHIPOBJECT__:
		{
			resp->insertBoolean(isShipObject());
		}
		break;
	case RPC_ISVEHICLEOBJECT__:
		{
			resp->insertBoolean(isVehicleObject());
		}
		break;
	case RPC_ISBUILDINGOBJECT__:
		{
			resp->insertBoolean(isBuildingObject());
		}
		break;
	case RPC_ISCLONINGBUILDINGOBJECT__:
		{
			resp->insertBoolean(isCloningBuildingObject());
		}
		break;
	case RPC_ISGARAGE__:
		{
			resp->insertBoolean(isGarage());
		}
		break;
	case RPC_ISWEAPONOBJECT__:
		{
			resp->insertBoolean(isWeaponObject());
		}
		break;
	case RPC_ISWEARABLEOBJECT__:
		{
			resp->insertBoolean(isWearableObject());
		}
		break;
	case RPC_ISARMOROBJECT__:
		{
			resp->insertBoolean(isArmorObject());
		}
		break;
	case RPC_ISROBEOBJECT__:
		{
			resp->insertBoolean(isRobeObject());
		}
		break;
	case RPC_ISLIGHTSABERCRYSTALOBJECT__:
		{
			resp->insertBoolean(isLightsaberCrystalObject());
		}
		break;
	case RPC_ISFIREWORKOBJECT__:
		{
			resp->insertBoolean(isFireworkObject());
		}
		break;
	case RPC_ISPSGARMOROBJECT__:
		{
			resp->insertBoolean(isPsgArmorObject());
		}
		break;
	case RPC_ISCELLOBJECT__:
		{
			resp->insertBoolean(isCellObject());
		}
		break;
	case RPC_ISTANGIBLEOBJECT__:
		{
			resp->insertBoolean(isTangibleObject());
		}
		break;
	case RPC_ISRESOURCECONTAINER__:
		{
			resp->insertBoolean(isResourceContainer());
		}
		break;
	case RPC_ISRESOURCESPAWN__:
		{
			resp->insertBoolean(isResourceSpawn());
		}
		break;
	case RPC_ISCOMPONENT__:
		{
			resp->insertBoolean(isComponent());
		}
		break;
	case RPC_ISINTANGIBLEOBJECT__:
		{
			resp->insertBoolean(isIntangibleObject());
		}
		break;
	case RPC_ISINSTRUMENT__:
		{
			resp->insertBoolean(isInstrument());
		}
		break;
	case RPC_ISBAZAARTERMINAL__:
		{
			resp->insertBoolean(isBazaarTerminal());
		}
		break;
	case RPC_ISLIVESAMPLE__:
		{
			resp->insertBoolean(isLiveSample());
		}
		break;
	case RPC_ISINSTALLATIONOBJECT__:
		{
			resp->insertBoolean(isInstallationObject());
		}
		break;
	case RPC_ISHARVESTEROBJECT__:
		{
			resp->insertBoolean(isHarvesterObject());
		}
		break;
	case RPC_ISGENERATOROBJECT__:
		{
			resp->insertBoolean(isGeneratorObject());
		}
		break;
	case RPC_ISCITYTERMINAL__:
		{
			resp->insertBoolean(isCityTerminal());
		}
		break;
	case RPC_ISCITYVOTETERMINAL__:
		{
			resp->insertBoolean(isCityVoteTerminal());
		}
		break;
	case RPC_ISFACTORY__:
		{
			resp->insertBoolean(isFactory());
		}
		break;
	case RPC_ISFACTORYCRATE__:
		{
			resp->insertBoolean(isFactoryCrate());
		}
		break;
	case RPC_ISFISHINGPOLEOBJECT__:
		{
			resp->insertBoolean(isFishingPoleObject());
		}
		break;
	case RPC_ISDEEDOBJECT__:
		{
			resp->insertBoolean(isDeedObject());
		}
		break;
	case RPC_ISVEHICLEDEEDOBJECT__:
		{
			resp->insertBoolean(isVehicleDeedObject());
		}
		break;
	case RPC_ISBUILDINGDEED__:
		{
			resp->insertBoolean(isBuildingDeed());
		}
		break;
	case RPC_ISSIGNOBJECT__:
		{
			resp->insertBoolean(isSignObject());
		}
		break;
	case RPC_ISINSTALLATIONDEED__:
		{
			resp->insertBoolean(isInstallationDeed());
		}
		break;
	case RPC_ISCRAFTINGTOOL__:
		{
			resp->insertBoolean(isCraftingTool());
		}
		break;
	case RPC_ISCRAFTINGSTATION__:
		{
			resp->insertBoolean(isCraftingStation());
		}
		break;
	case RPC_ISMANUFACTURESCHEMATIC__:
		{
			resp->insertBoolean(isManufactureSchematic());
		}
		break;
	case RPC_ISSTRUCTUREOBJECT__:
		{
			resp->insertBoolean(isStructureObject());
		}
		break;
	case RPC_ISAUCTIONOBJECT__:
		{
			resp->insertBoolean(isAuctionObject());
		}
		break;
	case RPC_ISFISHINGBAIT__:
		{
			resp->insertBoolean(isFishingBait());
		}
		break;
	case RPC_ISTRAPOBJECT__:
		{
			resp->insertBoolean(isTrapObject());
		}
		break;
	case RPC_ISREPAIRTOOL__:
		{
			resp->insertBoolean(isRepairTool());
		}
		break;
	case RPC_ISCAMOKIT__:
		{
			resp->insertBoolean(isCamoKit());
		}
		break;
	case RPC_ISATTACHMENT__:
		{
			resp->insertBoolean(isAttachment());
		}
		break;
	case RPC_ISDICEOBJECT__:
		{
			resp->insertBoolean(isDiceObject());
		}
		break;
	case RPC_ISCREATUREHABITAT__:
		{
			resp->insertBoolean(isCreatureHabitat());
		}
		break;
	case RPC_ISCAMPKIT__:
		{
			resp->insertBoolean(isCampKit());
		}
		break;
	case RPC_ISCAMPSTRUCTURE__:
		{
			resp->insertBoolean(isCampStructure());
		}
		break;
	case RPC_SETCONTAINERDEFAULTALLOWPERMISSION__SHORT_:
		{
			setContainerDefaultAllowPermission(inv->getUnsignedShortParameter());
		}
		break;
	case RPC_CLEARCONTAINERDEFAULTALLOWPERMISSION__SHORT_:
		{
			clearContainerDefaultAllowPermission(inv->getUnsignedShortParameter());
		}
		break;
	case RPC_SETCONTAINERDEFAULTDENYPERMISSION__SHORT_:
		{
			setContainerDefaultDenyPermission(inv->getUnsignedShortParameter());
		}
		break;
	case RPC_CLEARCONTAINERDEFAULTDENYPERMISSION__SHORT_:
		{
			clearContainerDefaultDenyPermission(inv->getUnsignedShortParameter());
		}
		break;
	case RPC_SETCONTAINERINHERITPERMISSIONSFROMPARENT__BOOL_:
		{
			setContainerInheritPermissionsFromParent(inv->getBooleanParameter());
		}
		break;
	case RPC_SETCONTAINEROWNERID__LONG_:
		{
			setContainerOwnerID(inv->getUnsignedLongParameter());
		}
		break;
	case RPC_SETCONTAINERALLOWPERMISSION__STRING_SHORT_:
		{
			String group; 
			setContainerAllowPermission(inv->getAsciiParameter(group), inv->getUnsignedShortParameter());
		}
		break;
	case RPC_SETCONTAINERDENYPERMISSION__STRING_SHORT_:
		{
			String group; 
			setContainerDenyPermission(inv->getAsciiParameter(group), inv->getUnsignedShortParameter());
		}
		break;
	case RPC_SETGAMEOBJECTTYPE__INT_:
		{
			setGameObjectType(inv->getUnsignedIntParameter());
		}
		break;
	case RPC_SETCLIENTOBJECTCRC__INT_:
		{
			setClientObjectCRC(inv->getUnsignedIntParameter());
		}
		break;
	case RPC_SETSERVEROBJECTCRC__INT_:
		{
			setServerObjectCRC(inv->getUnsignedIntParameter());
		}
		break;
	case RPC_SETZONE__ZONE_:
		{
			setZone(static_cast<Zone*>(inv->getObjectParameter()));
		}
		break;
	case RPC_SETDIRECTION__FLOAT_FLOAT_FLOAT_FLOAT_:
		{
			setDirection(inv->getFloatParameter(), inv->getFloatParameter(), inv->getFloatParameter(), inv->getFloatParameter());
		}
		break;
	case RPC_SETDIRECTION__FLOAT_:
		{
			setDirection(inv->getFloatParameter());
		}
		break;
	case RPC_SETMOVEMENTCOUNTER__INT_:
		{
			setMovementCounter(inv->getUnsignedIntParameter());
		}
		break;
	case RPC_INCREMENTMOVEMENTCOUNTER__:
		{
			incrementMovementCounter();
		}
		break;
	case RPC_SETCONTAINMENTTYPE__INT_:
		{
			setContainmentType(inv->getUnsignedIntParameter());
		}
		break;
	case RPC_SETLOGGINGNAME__STRING_:
		{
			String name; 
			setLoggingName(inv->getAsciiParameter(name));
		}
		break;
	case RPC_SETCLIENTOBJECT__BOOL_:
		{
			setClientObject(inv->getBooleanParameter());
		}
		break;
	case RPC_GETPLANETCRC__:
		{
			resp->insertInt(getPlanetCRC());
		}
		break;
	case RPC_ISSTATICOBJECT__:
		{
			resp->insertBoolean(isStaticObject());
		}
		break;
	case RPC_ISCONTAINEROBJECT__:
		{
			resp->insertBoolean(isContainerObject());
		}
		break;
	case RPC_ISTERMINAL__:
		{
			resp->insertBoolean(isTerminal());
		}
		break;
	case RPC_ISGROUPOBJECT__:
		{
			resp->insertBoolean(isGroupObject());
		}
		break;
	case RPC_ISGUILDOBJECT__:
		{
			resp->insertBoolean(isGuildObject());
		}
		break;
	case RPC_ISCONTROLDEVICE__:
		{
			resp->insertBoolean(isControlDevice());
		}
		break;
	case RPC_ISMISSIONTERMINAL__:
		{
			resp->insertBoolean(isMissionTerminal());
		}
		break;
	case RPC_ISMISSIONOBJECT__:
		{
			resp->insertBoolean(isMissionObject());
		}
		break;
	case RPC_ISACTOROBJECT__:
		{
			resp->insertBoolean(isActorObject());
		}
		break;
	case RPC_GETPLANETMAPCATEGORYCRC__:
		{
			resp->insertSignedInt(getPlanetMapCategoryCRC());
		}
		break;
	case RPC_GETPLANETMAPSUBCATEGORYCRC__:
		{
			resp->insertSignedInt(getPlanetMapSubCategoryCRC());
		}
		break;
	case RPC_CONTAINSCHILDOBJECT__SCENEOBJECT_:
		{
			resp->insertBoolean(containsChildObject(static_cast<SceneObject*>(inv->getObjectParameter())));
		}
		break;
	case RPC_CREATECHILDOBJECTS__:
		{
			createChildObjects();
		}
		break;
	case RPC_INITIALIZECHILDOBJECT__SCENEOBJECT_:
		{
			initializeChildObject(static_cast<SceneObject*>(inv->getObjectParameter()));
		}
		break;
	case RPC_ISINWATER__:
		{
			resp->insertBoolean(isInWater());
		}
		break;
	case RPC_GETDISPLAYEDNAME__:
		{
			resp->insertAscii(getDisplayedName());
		}
		break;
	case RPC_DOSENDTOCLIENT__:
		{
			resp->insertBoolean(doSendToClient());
		}
		break;
	case RPC_SETSENDTOCLIENT__BOOL_:
		{
			setSendToClient(inv->getBooleanParameter());
		}
		break;
	default:
		throw Exception("Method does not exists");
	}
}

void SceneObjectAdapter::finalize() {
	(static_cast<SceneObject*>(stub))->finalize();
}

void SceneObjectAdapter::initializePrivateData() {
	(static_cast<SceneObject*>(stub))->initializePrivateData();
}

void SceneObjectAdapter::createComponents() {
	(static_cast<SceneObject*>(stub))->createComponents();
}

void SceneObjectAdapter::createContainerComponent() {
	(static_cast<SceneObject*>(stub))->createContainerComponent();
}

void SceneObjectAdapter::initializeTransientMembers() {
	(static_cast<SceneObject*>(stub))->initializeTransientMembers();
}

void SceneObjectAdapter::notifyLoadFromDatabase() {
	(static_cast<SceneObject*>(stub))->notifyLoadFromDatabase();
}

void SceneObjectAdapter::info(const String& msg, bool forced) {
	(static_cast<SceneObject*>(stub))->info(msg, forced);
}

void SceneObjectAdapter::error(const String& msg) {
	(static_cast<SceneObject*>(stub))->error(msg);
}

int SceneObjectAdapter::inRangeObjects(unsigned int gameObjectType, float range) {
	return (static_cast<SceneObject*>(stub))->inRangeObjects(gameObjectType, range);
}

bool SceneObjectAdapter::isInRange(SceneObject* obj, float range) {
	return (static_cast<SceneObject*>(stub))->isInRange(obj, range);
}

bool SceneObjectAdapter::transferObject(SceneObject* object, int containmentType, bool notifyClient) {
	return (static_cast<SceneObject*>(stub))->transferObject(object, containmentType, notifyClient);
}

bool SceneObjectAdapter::removeObject(SceneObject* object, SceneObject* destination, bool notifyClient) {
	return (static_cast<SceneObject*>(stub))->removeObject(object, destination, notifyClient);
}

void SceneObjectAdapter::destroyObjectFromWorld(bool sendSelfDestroy) {
	(static_cast<SceneObject*>(stub))->destroyObjectFromWorld(sendSelfDestroy);
}

int SceneObjectAdapter::canAddObject(SceneObject* object, int containmentType, String& errorDescription) {
	return (static_cast<SceneObject*>(stub))->canAddObject(object, containmentType, errorDescription);
}

int SceneObjectAdapter::notifyObjectInsertedToChild(SceneObject* object, SceneObject* child, SceneObject* oldParent) {
	return (static_cast<SceneObject*>(stub))->notifyObjectInsertedToChild(object, child, oldParent);
}

int SceneObjectAdapter::notifyObjectRemovedFromChild(SceneObject* object, SceneObject* child) {
	return (static_cast<SceneObject*>(stub))->notifyObjectRemovedFromChild(object, child);
}

void SceneObjectAdapter::synchronizedUIListen(SceneObject* player, int value) {
	(static_cast<SceneObject*>(stub))->synchronizedUIListen(player, value);
}

void SceneObjectAdapter::synchronizedUIStopListen(SceneObject* player, int value) {
	(static_cast<SceneObject*>(stub))->synchronizedUIStopListen(player, value);
}

void SceneObjectAdapter::updateToDatabase() {
	(static_cast<SceneObject*>(stub))->updateToDatabase();
}

void SceneObjectAdapter::updateToDatabaseWithoutChildren() {
	(static_cast<SceneObject*>(stub))->updateToDatabaseWithoutChildren();
}

void SceneObjectAdapter::updateToDatabaseAllObjects(bool startTask) {
	(static_cast<SceneObject*>(stub))->updateToDatabaseAllObjects(startTask);
}

void SceneObjectAdapter::destroyPlayerCreatureFromDatabase(bool destroyContainedObjects) {
	(static_cast<SceneObject*>(stub))->destroyPlayerCreatureFromDatabase(destroyContainedObjects);
}

void SceneObjectAdapter::destroyObjectFromDatabase(bool destroyContainedObjects) {
	(static_cast<SceneObject*>(stub))->destroyObjectFromDatabase(destroyContainedObjects);
}

int SceneObjectAdapter::canBeDestroyed(CreatureObject* player) {
	return (static_cast<SceneObject*>(stub))->canBeDestroyed(player);
}

BaseMessage* SceneObjectAdapter::link(unsigned long long objectID, unsigned int containmentType) {
	return (static_cast<SceneObject*>(stub))->link(objectID, containmentType);
}

void SceneObjectAdapter::sendTo(SceneObject* player, bool doClose) {
	(static_cast<SceneObject*>(stub))->sendTo(player, doClose);
}

void SceneObjectAdapter::sendWithoutParentTo(SceneObject* player) {
	(static_cast<SceneObject*>(stub))->sendWithoutParentTo(player);
}

void SceneObjectAdapter::sendWithoutContainerObjectsTo(SceneObject* player) {
	(static_cast<SceneObject*>(stub))->sendWithoutContainerObjectsTo(player);
}

void SceneObjectAdapter::sendDestroyTo(SceneObject* player) {
	(static_cast<SceneObject*>(stub))->sendDestroyTo(player);
}

void SceneObjectAdapter::sendBaselinesTo(SceneObject* player) {
	(static_cast<SceneObject*>(stub))->sendBaselinesTo(player);
}

void SceneObjectAdapter::sendContainerObjectsTo(SceneObject* player) {
	(static_cast<SceneObject*>(stub))->sendContainerObjectsTo(player);
}

void SceneObjectAdapter::sendSlottedObjectsTo(SceneObject* player) {
	(static_cast<SceneObject*>(stub))->sendSlottedObjectsTo(player);
}

void SceneObjectAdapter::sendToOwner(bool doClose) {
	(static_cast<SceneObject*>(stub))->sendToOwner(doClose);
}

void SceneObjectAdapter::sendAttributeListTo(CreatureObject* object) {
	(static_cast<SceneObject*>(stub))->sendAttributeListTo(object);
}

void SceneObjectAdapter::setCustomObjectName(const UnicodeString& name, bool notifyClient) {
	(static_cast<SceneObject*>(stub))->setCustomObjectName(name, notifyClient);
}

void SceneObjectAdapter::openContainerTo(CreatureObject* player) {
	(static_cast<SceneObject*>(stub))->openContainerTo(player);
}

void SceneObjectAdapter::closeContainerTo(CreatureObject* player, bool notify) {
	(static_cast<SceneObject*>(stub))->closeContainerTo(player, notify);
}

void SceneObjectAdapter::notifyInsertToZone(Zone* zone) {
	(static_cast<SceneObject*>(stub))->notifyInsertToZone(zone);
}

void SceneObjectAdapter::switchZone(const String& newTerrainName, float newPostionX, float newPositionZ, float newPositionY, unsigned long long parentID) {
	(static_cast<SceneObject*>(stub))->switchZone(newTerrainName, newPostionX, newPositionZ, newPositionY, parentID);
}

void SceneObjectAdapter::teleport(float newPositionX, float newPositionZ, float newPositionY, unsigned long long parentID) {
	(static_cast<SceneObject*>(stub))->teleport(newPositionX, newPositionZ, newPositionY, parentID);
}

void SceneObjectAdapter::updateDirection(float fw, float fx, float fy, float fz) {
	(static_cast<SceneObject*>(stub))->updateDirection(fw, fx, fy, fz);
}

void SceneObjectAdapter::updateDirection(float angleHeadingRadians) {
	(static_cast<SceneObject*>(stub))->updateDirection(angleHeadingRadians);
}

void SceneObjectAdapter::notifyRemoveFromZone() {
	(static_cast<SceneObject*>(stub))->notifyRemoveFromZone();
}

void SceneObjectAdapter::updateZone(bool lightUpdate, bool sendPackets) {
	(static_cast<SceneObject*>(stub))->updateZone(lightUpdate, sendPackets);
}

void SceneObjectAdapter::updateZoneWithParent(SceneObject* newParent, bool lightUpdate, bool sendPackets) {
	(static_cast<SceneObject*>(stub))->updateZoneWithParent(newParent, lightUpdate, sendPackets);
}

void SceneObjectAdapter::broadcastMessage(BasePacket* message, bool sendSelf, bool lockZone) {
	(static_cast<SceneObject*>(stub))->broadcastMessage(message, sendSelf, lockZone);
}

void SceneObjectAdapter::broadcastMessagePrivate(BasePacket* message, SceneObject* selfObject, bool lockZone) {
	(static_cast<SceneObject*>(stub))->broadcastMessagePrivate(message, selfObject, lockZone);
}

void SceneObjectAdapter::broadcastObject(SceneObject* object, bool sendSelf) {
	(static_cast<SceneObject*>(stub))->broadcastObject(object, sendSelf);
}

void SceneObjectAdapter::broadcastObjectPrivate(SceneObject* object, SceneObject* selfObject) {
	(static_cast<SceneObject*>(stub))->broadcastObjectPrivate(object, selfObject);
}

void SceneObjectAdapter::broadcastDestroy(SceneObject* object, bool sendSelf) {
	(static_cast<SceneObject*>(stub))->broadcastDestroy(object, sendSelf);
}

void SceneObjectAdapter::broadcastDestroyPrivate(SceneObject* object, SceneObject* selfObject) {
	(static_cast<SceneObject*>(stub))->broadcastDestroyPrivate(object, selfObject);
}

void SceneObjectAdapter::sendMessage(BasePacket* msg) {
	(static_cast<SceneObject*>(stub))->sendMessage(msg);
}

int SceneObjectAdapter::compareTo(SceneObject* obj) {
	return (static_cast<SceneObject*>(stub))->compareTo(obj);
}

unsigned long long SceneObjectAdapter::getParentID() {
	return (static_cast<SceneObject*>(stub))->getParentID();
}

bool SceneObjectAdapter::containsPendingTask(const String& name) {
	return (static_cast<SceneObject*>(stub))->containsPendingTask(name);
}

void SceneObjectAdapter::showFlyText(const String& file, const String& uax, byte red, byte green, byte blue) {
	(static_cast<SceneObject*>(stub))->showFlyText(file, uax, red, green, blue);
}

int SceneObjectAdapter::getContainedObjectsRecursive() {
	return (static_cast<SceneObject*>(stub))->getContainedObjectsRecursive();
}

Facade* SceneObjectAdapter::getActiveSession(unsigned int type) {
	return (static_cast<SceneObject*>(stub))->getActiveSession(type);
}

void SceneObjectAdapter::addActiveSession(unsigned int type, Facade* session) {
	(static_cast<SceneObject*>(stub))->addActiveSession(type, session);
}

bool SceneObjectAdapter::containsActiveSession(unsigned int type) {
	return (static_cast<SceneObject*>(stub))->containsActiveSession(type);
}

bool SceneObjectAdapter::dropActiveSession(unsigned int type) {
	return (static_cast<SceneObject*>(stub))->dropActiveSession(type);
}

int SceneObjectAdapter::getActiveSessionsCount() {
	return (static_cast<SceneObject*>(stub))->getActiveSessionsCount();
}

int SceneObjectAdapter::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
	return (static_cast<SceneObject*>(stub))->handleObjectMenuSelect(player, selectedID);
}

float SceneObjectAdapter::getDistanceTo(SceneObject* object) {
	return (static_cast<SceneObject*>(stub))->getDistanceTo(object);
}

void SceneObjectAdapter::updateVehiclePosition(bool sendPackets) {
	(static_cast<SceneObject*>(stub))->updateVehiclePosition(sendPackets);
}

int SceneObjectAdapter::notifyObjectInserted(SceneObject* object) {
	return (static_cast<SceneObject*>(stub))->notifyObjectInserted(object);
}

int SceneObjectAdapter::notifyObjectRemoved(SceneObject* object) {
	return (static_cast<SceneObject*>(stub))->notifyObjectRemoved(object);
}

void SceneObjectAdapter::addActiveArea(ActiveArea* area) {
	(static_cast<SceneObject*>(stub))->addActiveArea(area);
}

void SceneObjectAdapter::dropActiveArea(ActiveArea* area) {
	(static_cast<SceneObject*>(stub))->dropActiveArea(area);
}

bool SceneObjectAdapter::hasActiveArea(ActiveArea* area) {
	return (static_cast<SceneObject*>(stub))->hasActiveArea(area);
}

bool SceneObjectAdapter::hasActiveArea(unsigned long long objectid) {
	return (static_cast<SceneObject*>(stub))->hasActiveArea(objectid);
}

int SceneObjectAdapter::getActiveAreasSize() {
	return (static_cast<SceneObject*>(stub))->getActiveAreasSize();
}

ActiveArea* SceneObjectAdapter::getActiveRegion() {
	return (static_cast<SceneObject*>(stub))->getActiveRegion();
}

Zone* SceneObjectAdapter::getZone() {
	return (static_cast<SceneObject*>(stub))->getZone();
}

Zone* SceneObjectAdapter::getLocalZone() {
	return (static_cast<SceneObject*>(stub))->getLocalZone();
}

unsigned long long SceneObjectAdapter::getObjectID() {
	return (static_cast<SceneObject*>(stub))->getObjectID();
}

float SceneObjectAdapter::getWorldPositionX() {
	return (static_cast<SceneObject*>(stub))->getWorldPositionX();
}

float SceneObjectAdapter::getWorldPositionY() {
	return (static_cast<SceneObject*>(stub))->getWorldPositionY();
}

float SceneObjectAdapter::getWorldPositionZ() {
	return (static_cast<SceneObject*>(stub))->getWorldPositionZ();
}

float SceneObjectAdapter::getDirectionX() {
	return (static_cast<SceneObject*>(stub))->getDirectionX();
}

float SceneObjectAdapter::getDirectionZ() {
	return (static_cast<SceneObject*>(stub))->getDirectionZ();
}

float SceneObjectAdapter::getDirectionY() {
	return (static_cast<SceneObject*>(stub))->getDirectionY();
}

float SceneObjectAdapter::getDirectionW() {
	return (static_cast<SceneObject*>(stub))->getDirectionW();
}

unsigned int SceneObjectAdapter::getClientObjectCRC() {
	return (static_cast<SceneObject*>(stub))->getClientObjectCRC();
}

unsigned int SceneObjectAdapter::getServerObjectCRC() {
	return (static_cast<SceneObject*>(stub))->getServerObjectCRC();
}

bool SceneObjectAdapter::isWaypointObject() {
	return (static_cast<SceneObject*>(stub))->isWaypointObject();
}

String SceneObjectAdapter::getObjectNameStringIdFile() {
	return (static_cast<SceneObject*>(stub))->getObjectNameStringIdFile();
}

String SceneObjectAdapter::getObjectNameStringIdName() {
	return (static_cast<SceneObject*>(stub))->getObjectNameStringIdName();
}

void SceneObjectAdapter::setDetailedDescription(const String& detail) {
	(static_cast<SceneObject*>(stub))->setDetailedDescription(detail);
}

int SceneObjectAdapter::getArrangementDescriptorSize() {
	return (static_cast<SceneObject*>(stub))->getArrangementDescriptorSize();
}

String SceneObjectAdapter::getArrangementDescriptor(int idx) {
	return (static_cast<SceneObject*>(stub))->getArrangementDescriptor(idx);
}

String SceneObjectAdapter::getSlotDescriptor(int idx) {
	return (static_cast<SceneObject*>(stub))->getSlotDescriptor(idx);
}

bool SceneObjectAdapter::hasSlotDescriptor(const String& descr) {
	return (static_cast<SceneObject*>(stub))->hasSlotDescriptor(descr);
}

bool SceneObjectAdapter::hasArrangementDescriptor(const String& descr) {
	return (static_cast<SceneObject*>(stub))->hasArrangementDescriptor(descr);
}

SceneObject* SceneObjectAdapter::getSlottedObject(const String& slot) {
	return (static_cast<SceneObject*>(stub))->getSlottedObject(slot);
}

int SceneObjectAdapter::getSlotDescriptorSize() {
	return (static_cast<SceneObject*>(stub))->getSlotDescriptorSize();
}

SceneObject* SceneObjectAdapter::getSlottedObject(int idx) {
	return (static_cast<SceneObject*>(stub))->getSlottedObject(idx);
}

void SceneObjectAdapter::dropSlottedObject(const String& arrengementDescriptor) {
	(static_cast<SceneObject*>(stub))->dropSlottedObject(arrengementDescriptor);
}

void SceneObjectAdapter::removeSlottedObject(int index) {
	(static_cast<SceneObject*>(stub))->removeSlottedObject(index);
}

int SceneObjectAdapter::getContainerObjectsSize() {
	return (static_cast<SceneObject*>(stub))->getContainerObjectsSize();
}

int SceneObjectAdapter::getSlottedObjectsSize() {
	return (static_cast<SceneObject*>(stub))->getSlottedObjectsSize();
}

bool SceneObjectAdapter::hasFullContainerObjects() {
	return (static_cast<SceneObject*>(stub))->hasFullContainerObjects();
}

unsigned int SceneObjectAdapter::getContainerVolumeLimit() {
	return (static_cast<SceneObject*>(stub))->getContainerVolumeLimit();
}

SceneObject* SceneObjectAdapter::getContainerObject(int idx) {
	return (static_cast<SceneObject*>(stub))->getContainerObject(idx);
}

bool SceneObjectAdapter::hasObjectInContainer(unsigned long long objectID) {
	return (static_cast<SceneObject*>(stub))->hasObjectInContainer(objectID);
}

bool SceneObjectAdapter::hasObjectInSlottedContainer(SceneObject* object) {
	return (static_cast<SceneObject*>(stub))->hasObjectInSlottedContainer(object);
}

SceneObject* SceneObjectAdapter::getContainerObject(unsigned long long objectID) {
	return (static_cast<SceneObject*>(stub))->getContainerObject(objectID);
}

void SceneObjectAdapter::removeAllContainerObjects() {
	(static_cast<SceneObject*>(stub))->removeAllContainerObjects();
}

void SceneObjectAdapter::putInContainer(SceneObject* obj, unsigned long long key) {
	(static_cast<SceneObject*>(stub))->putInContainer(obj, key);
}

void SceneObjectAdapter::removeFromContainerObjects(int index) {
	(static_cast<SceneObject*>(stub))->removeFromContainerObjects(index);
}

void SceneObjectAdapter::setContainerVolumeLimit(int lim) {
	(static_cast<SceneObject*>(stub))->setContainerVolumeLimit(lim);
}

void SceneObjectAdapter::setContainerType(int type) {
	(static_cast<SceneObject*>(stub))->setContainerType(type);
}

unsigned int SceneObjectAdapter::getContainerType() {
	return (static_cast<SceneObject*>(stub))->getContainerType();
}

ZoneClientSession* SceneObjectAdapter::getClient() {
	return (static_cast<SceneObject*>(stub))->getClient();
}

unsigned int SceneObjectAdapter::getGameObjectType() {
	return (static_cast<SceneObject*>(stub))->getGameObjectType();
}

unsigned int SceneObjectAdapter::getClientGameObjectType() {
	return (static_cast<SceneObject*>(stub))->getClientGameObjectType();
}

unsigned int SceneObjectAdapter::getContainmentType() {
	return (static_cast<SceneObject*>(stub))->getContainmentType();
}

float SceneObjectAdapter::getDirectionAngle() {
	return (static_cast<SceneObject*>(stub))->getDirectionAngle();
}

float SceneObjectAdapter::getSpecialDirectionAngle() {
	return (static_cast<SceneObject*>(stub))->getSpecialDirectionAngle();
}

void SceneObjectAdapter::rotate(int degrees) {
	(static_cast<SceneObject*>(stub))->rotate(degrees);
}

void SceneObjectAdapter::faceObject(SceneObject* obj) {
	(static_cast<SceneObject*>(stub))->faceObject(obj);
}

void SceneObjectAdapter::notifySelfPositionUpdate() {
	(static_cast<SceneObject*>(stub))->notifySelfPositionUpdate();
}

void SceneObjectAdapter::notifyPositionUpdate(QuadTreeEntry* entry) {
	(static_cast<SceneObject*>(stub))->notifyPositionUpdate(entry);
}

void SceneObjectAdapter::notifyCloseContainer(CreatureObject* player) {
	(static_cast<SceneObject*>(stub))->notifyCloseContainer(player);
}

unsigned int SceneObjectAdapter::getMovementCounter() {
	return (static_cast<SceneObject*>(stub))->getMovementCounter();
}

ManagedWeakReference<SceneObject* > SceneObjectAdapter::getParent() {
	return (static_cast<SceneObject*>(stub))->getParent();
}

ZoneServer* SceneObjectAdapter::getZoneServer() {
	return (static_cast<SceneObject*>(stub))->getZoneServer();
}

ManagedWeakReference<SceneObject* > SceneObjectAdapter::getRootParent() {
	return (static_cast<SceneObject*>(stub))->getRootParent();
}

ManagedWeakReference<SceneObject* > SceneObjectAdapter::getParentRecursively(unsigned int gameObjectType) {
	return (static_cast<SceneObject*>(stub))->getParentRecursively(gameObjectType);
}

bool SceneObjectAdapter::isASubChildOf(SceneObject* object) {
	return (static_cast<SceneObject*>(stub))->isASubChildOf(object);
}

UnicodeString SceneObjectAdapter::getCustomObjectName() {
	return (static_cast<SceneObject*>(stub))->getCustomObjectName();
}

String SceneObjectAdapter::getLoggingName() {
	return (static_cast<SceneObject*>(stub))->getLoggingName();
}

bool SceneObjectAdapter::isPlayerCreature() {
	return (static_cast<SceneObject*>(stub))->isPlayerCreature();
}

bool SceneObjectAdapter::isNoTrade() {
	return (static_cast<SceneObject*>(stub))->isNoTrade();
}

bool SceneObjectAdapter::isContainerFull() {
	return (static_cast<SceneObject*>(stub))->isContainerFull();
}

bool SceneObjectAdapter::isShuttleInstallation() {
	return (static_cast<SceneObject*>(stub))->isShuttleInstallation();
}

bool SceneObjectAdapter::isPlayerObject() {
	return (static_cast<SceneObject*>(stub))->isPlayerObject();
}

bool SceneObjectAdapter::isActiveArea() {
	return (static_cast<SceneObject*>(stub))->isActiveArea();
}

bool SceneObjectAdapter::isRegion() {
	return (static_cast<SceneObject*>(stub))->isRegion();
}

bool SceneObjectAdapter::isCreatureObject() {
	return (static_cast<SceneObject*>(stub))->isCreatureObject();
}

bool SceneObjectAdapter::isAiAgent() {
	return (static_cast<SceneObject*>(stub))->isAiAgent();
}

bool SceneObjectAdapter::isShipObject() {
	return (static_cast<SceneObject*>(stub))->isShipObject();
}

bool SceneObjectAdapter::isVehicleObject() {
	return (static_cast<SceneObject*>(stub))->isVehicleObject();
}

bool SceneObjectAdapter::isBuildingObject() {
	return (static_cast<SceneObject*>(stub))->isBuildingObject();
}

bool SceneObjectAdapter::isCloningBuildingObject() {
	return (static_cast<SceneObject*>(stub))->isCloningBuildingObject();
}

bool SceneObjectAdapter::isGarage() {
	return (static_cast<SceneObject*>(stub))->isGarage();
}

bool SceneObjectAdapter::isWeaponObject() {
	return (static_cast<SceneObject*>(stub))->isWeaponObject();
}

bool SceneObjectAdapter::isWearableObject() {
	return (static_cast<SceneObject*>(stub))->isWearableObject();
}

bool SceneObjectAdapter::isArmorObject() {
	return (static_cast<SceneObject*>(stub))->isArmorObject();
}

bool SceneObjectAdapter::isRobeObject() {
	return (static_cast<SceneObject*>(stub))->isRobeObject();
}

bool SceneObjectAdapter::isLightsaberCrystalObject() {
	return (static_cast<SceneObject*>(stub))->isLightsaberCrystalObject();
}

bool SceneObjectAdapter::isFireworkObject() {
	return (static_cast<SceneObject*>(stub))->isFireworkObject();
}

bool SceneObjectAdapter::isPsgArmorObject() {
	return (static_cast<SceneObject*>(stub))->isPsgArmorObject();
}

bool SceneObjectAdapter::isCellObject() {
	return (static_cast<SceneObject*>(stub))->isCellObject();
}

bool SceneObjectAdapter::isTangibleObject() {
	return (static_cast<SceneObject*>(stub))->isTangibleObject();
}

bool SceneObjectAdapter::isResourceContainer() {
	return (static_cast<SceneObject*>(stub))->isResourceContainer();
}

bool SceneObjectAdapter::isResourceSpawn() {
	return (static_cast<SceneObject*>(stub))->isResourceSpawn();
}

bool SceneObjectAdapter::isComponent() {
	return (static_cast<SceneObject*>(stub))->isComponent();
}

bool SceneObjectAdapter::isIntangibleObject() {
	return (static_cast<SceneObject*>(stub))->isIntangibleObject();
}

bool SceneObjectAdapter::isInstrument() {
	return (static_cast<SceneObject*>(stub))->isInstrument();
}

bool SceneObjectAdapter::isBazaarTerminal() {
	return (static_cast<SceneObject*>(stub))->isBazaarTerminal();
}

bool SceneObjectAdapter::isLiveSample() {
	return (static_cast<SceneObject*>(stub))->isLiveSample();
}

bool SceneObjectAdapter::isInstallationObject() {
	return (static_cast<SceneObject*>(stub))->isInstallationObject();
}

bool SceneObjectAdapter::isHarvesterObject() {
	return (static_cast<SceneObject*>(stub))->isHarvesterObject();
}

bool SceneObjectAdapter::isGeneratorObject() {
	return (static_cast<SceneObject*>(stub))->isGeneratorObject();
}

bool SceneObjectAdapter::isCityTerminal() {
	return (static_cast<SceneObject*>(stub))->isCityTerminal();
}

bool SceneObjectAdapter::isCityVoteTerminal() {
	return (static_cast<SceneObject*>(stub))->isCityVoteTerminal();
}

bool SceneObjectAdapter::isFactory() {
	return (static_cast<SceneObject*>(stub))->isFactory();
}

bool SceneObjectAdapter::isFactoryCrate() {
	return (static_cast<SceneObject*>(stub))->isFactoryCrate();
}

bool SceneObjectAdapter::isFishingPoleObject() {
	return (static_cast<SceneObject*>(stub))->isFishingPoleObject();
}

bool SceneObjectAdapter::isDeedObject() {
	return (static_cast<SceneObject*>(stub))->isDeedObject();
}

bool SceneObjectAdapter::isVehicleDeedObject() {
	return (static_cast<SceneObject*>(stub))->isVehicleDeedObject();
}

bool SceneObjectAdapter::isBuildingDeed() {
	return (static_cast<SceneObject*>(stub))->isBuildingDeed();
}

bool SceneObjectAdapter::isSignObject() {
	return (static_cast<SceneObject*>(stub))->isSignObject();
}

bool SceneObjectAdapter::isInstallationDeed() {
	return (static_cast<SceneObject*>(stub))->isInstallationDeed();
}

bool SceneObjectAdapter::isCraftingTool() {
	return (static_cast<SceneObject*>(stub))->isCraftingTool();
}

bool SceneObjectAdapter::isCraftingStation() {
	return (static_cast<SceneObject*>(stub))->isCraftingStation();
}

bool SceneObjectAdapter::isManufactureSchematic() {
	return (static_cast<SceneObject*>(stub))->isManufactureSchematic();
}

bool SceneObjectAdapter::isStructureObject() {
	return (static_cast<SceneObject*>(stub))->isStructureObject();
}

bool SceneObjectAdapter::isAuctionObject() {
	return (static_cast<SceneObject*>(stub))->isAuctionObject();
}

bool SceneObjectAdapter::isFishingBait() {
	return (static_cast<SceneObject*>(stub))->isFishingBait();
}

bool SceneObjectAdapter::isTrapObject() {
	return (static_cast<SceneObject*>(stub))->isTrapObject();
}

bool SceneObjectAdapter::isRepairTool() {
	return (static_cast<SceneObject*>(stub))->isRepairTool();
}

bool SceneObjectAdapter::isCamoKit() {
	return (static_cast<SceneObject*>(stub))->isCamoKit();
}

bool SceneObjectAdapter::isAttachment() {
	return (static_cast<SceneObject*>(stub))->isAttachment();
}

bool SceneObjectAdapter::isDiceObject() {
	return (static_cast<SceneObject*>(stub))->isDiceObject();
}

bool SceneObjectAdapter::isCreatureHabitat() {
	return (static_cast<SceneObject*>(stub))->isCreatureHabitat();
}

bool SceneObjectAdapter::isCampKit() {
	return (static_cast<SceneObject*>(stub))->isCampKit();
}

bool SceneObjectAdapter::isCampStructure() {
	return (static_cast<SceneObject*>(stub))->isCampStructure();
}

void SceneObjectAdapter::setContainerDefaultAllowPermission(unsigned short perm) {
	(static_cast<SceneObject*>(stub))->setContainerDefaultAllowPermission(perm);
}

void SceneObjectAdapter::clearContainerDefaultAllowPermission(unsigned short perm) {
	(static_cast<SceneObject*>(stub))->clearContainerDefaultAllowPermission(perm);
}

void SceneObjectAdapter::setContainerDefaultDenyPermission(unsigned short perm) {
	(static_cast<SceneObject*>(stub))->setContainerDefaultDenyPermission(perm);
}

void SceneObjectAdapter::clearContainerDefaultDenyPermission(unsigned short perm) {
	(static_cast<SceneObject*>(stub))->clearContainerDefaultDenyPermission(perm);
}

void SceneObjectAdapter::setContainerInheritPermissionsFromParent(bool val) {
	(static_cast<SceneObject*>(stub))->setContainerInheritPermissionsFromParent(val);
}

void SceneObjectAdapter::setContainerOwnerID(unsigned long long id) {
	(static_cast<SceneObject*>(stub))->setContainerOwnerID(id);
}

void SceneObjectAdapter::setContainerAllowPermission(const String& group, unsigned short perm) {
	(static_cast<SceneObject*>(stub))->setContainerAllowPermission(group, perm);
}

void SceneObjectAdapter::setContainerDenyPermission(const String& group, unsigned short perm) {
	(static_cast<SceneObject*>(stub))->setContainerDenyPermission(group, perm);
}

void SceneObjectAdapter::setGameObjectType(unsigned int type) {
	(static_cast<SceneObject*>(stub))->setGameObjectType(type);
}

void SceneObjectAdapter::setClientObjectCRC(unsigned int objCRC) {
	(static_cast<SceneObject*>(stub))->setClientObjectCRC(objCRC);
}

void SceneObjectAdapter::setServerObjectCRC(unsigned int objCRC) {
	(static_cast<SceneObject*>(stub))->setServerObjectCRC(objCRC);
}

void SceneObjectAdapter::setZone(Zone* zone) {
	(static_cast<SceneObject*>(stub))->setZone(zone);
}

void SceneObjectAdapter::setDirection(float fw, float fx, float fy, float fz) {
	(static_cast<SceneObject*>(stub))->setDirection(fw, fx, fy, fz);
}

void SceneObjectAdapter::setDirection(float headingAngleRadians) {
	(static_cast<SceneObject*>(stub))->setDirection(headingAngleRadians);
}

void SceneObjectAdapter::setMovementCounter(unsigned int count) {
	(static_cast<SceneObject*>(stub))->setMovementCounter(count);
}

void SceneObjectAdapter::incrementMovementCounter() {
	(static_cast<SceneObject*>(stub))->incrementMovementCounter();
}

void SceneObjectAdapter::setContainmentType(unsigned int type) {
	(static_cast<SceneObject*>(stub))->setContainmentType(type);
}

void SceneObjectAdapter::setLoggingName(const String& name) {
	(static_cast<SceneObject*>(stub))->setLoggingName(name);
}

void SceneObjectAdapter::setClientObject(bool val) {
	(static_cast<SceneObject*>(stub))->setClientObject(val);
}

unsigned int SceneObjectAdapter::getPlanetCRC() {
	return (static_cast<SceneObject*>(stub))->getPlanetCRC();
}

bool SceneObjectAdapter::isStaticObject() {
	return (static_cast<SceneObject*>(stub))->isStaticObject();
}

bool SceneObjectAdapter::isContainerObject() {
	return (static_cast<SceneObject*>(stub))->isContainerObject();
}

bool SceneObjectAdapter::isTerminal() {
	return (static_cast<SceneObject*>(stub))->isTerminal();
}

bool SceneObjectAdapter::isGroupObject() {
	return (static_cast<SceneObject*>(stub))->isGroupObject();
}

bool SceneObjectAdapter::isGuildObject() {
	return (static_cast<SceneObject*>(stub))->isGuildObject();
}

bool SceneObjectAdapter::isControlDevice() {
	return (static_cast<SceneObject*>(stub))->isControlDevice();
}

bool SceneObjectAdapter::isMissionTerminal() {
	return (static_cast<SceneObject*>(stub))->isMissionTerminal();
}

bool SceneObjectAdapter::isMissionObject() {
	return (static_cast<SceneObject*>(stub))->isMissionObject();
}

bool SceneObjectAdapter::isActorObject() {
	return (static_cast<SceneObject*>(stub))->isActorObject();
}

int SceneObjectAdapter::getPlanetMapCategoryCRC() {
	return (static_cast<SceneObject*>(stub))->getPlanetMapCategoryCRC();
}

int SceneObjectAdapter::getPlanetMapSubCategoryCRC() {
	return (static_cast<SceneObject*>(stub))->getPlanetMapSubCategoryCRC();
}

bool SceneObjectAdapter::containsChildObject(SceneObject* obj) {
	return (static_cast<SceneObject*>(stub))->containsChildObject(obj);
}

void SceneObjectAdapter::createChildObjects() {
	(static_cast<SceneObject*>(stub))->createChildObjects();
}

void SceneObjectAdapter::initializeChildObject(SceneObject* controllerObject) {
	(static_cast<SceneObject*>(stub))->initializeChildObject(controllerObject);
}

bool SceneObjectAdapter::isInWater() {
	return (static_cast<SceneObject*>(stub))->isInWater();
}

String SceneObjectAdapter::getDisplayedName() {
	return (static_cast<SceneObject*>(stub))->getDisplayedName();
}

bool SceneObjectAdapter::doSendToClient() {
	return (static_cast<SceneObject*>(stub))->doSendToClient();
}

void SceneObjectAdapter::setSendToClient(bool val) {
	(static_cast<SceneObject*>(stub))->setSendToClient(val);
}

/*
 *	SceneObjectHelper
 */

SceneObjectHelper* SceneObjectHelper::staticInitializer = SceneObjectHelper::instance();

SceneObjectHelper::SceneObjectHelper() {
	className = "SceneObject";

	Core::getObjectBroker()->registerClass(className, this);
}

void SceneObjectHelper::finalizeHelper() {
	SceneObjectHelper::finalize();
}

DistributedObject* SceneObjectHelper::instantiateObject() {
	return new SceneObject(DummyConstructorParameter::instance());
}

DistributedObjectServant* SceneObjectHelper::instantiateServant() {
	return new SceneObjectImplementation();
}

DistributedObjectAdapter* SceneObjectHelper::createAdapter(DistributedObjectStub* obj) {
	DistributedObjectAdapter* adapter = new SceneObjectAdapter(static_cast<SceneObject*>(obj));

	obj->_setClassName(className);
	obj->_setClassHelper(this);

	adapter->setStub(obj);

	return adapter;
}