void ZoneComponent::updateInRangeObjectsOnMount(SceneObject* sceneObject) {
CloseObjectsVector* closeObjectsVector = (CloseObjectsVector*) sceneObject->getCloseObjects();
CloseObjectsVector* parentCloseObjectsVector = (CloseObjectsVector*) sceneObject->getRootParent().get()->getCloseObjects();
SortedVector<ManagedReference<QuadTreeEntry*> > closeObjects(closeObjectsVector->size(), 10);
closeObjectsVector->safeCopyTo(closeObjects);
SortedVector<ManagedReference<QuadTreeEntry*> > parentCloseObjects(parentCloseObjectsVector->size(), 10);
parentCloseObjectsVector->safeCopyTo(parentCloseObjects);
//remove old ones
float rangesq = 192.f * 192.f;
float x = sceneObject->getPositionX();
float y = sceneObject->getPositionY();
float oldx = sceneObject->getPreviousPositionX();
float oldy = sceneObject->getPreviousPositionY();
for (int i = 0; i < closeObjects.size(); ++i) {
ManagedReference<QuadTreeEntry*> o = closeObjects.get(i);
ManagedReference<QuadTreeEntry*> objectToRemove = o;
ManagedReference<QuadTreeEntry*> rootParent = o->getRootParent();
if (rootParent != NULL)
o = rootParent;
if (o != sceneObject) {
float deltaX = x - o->getPositionX();
float deltaY = y - o->getPositionY();
if (deltaX * deltaX + deltaY * deltaY > rangesq) {
float oldDeltaX = oldx - o->getPositionX();
float oldDeltaY = oldy - o->getPositionY();
if (oldDeltaX * oldDeltaX + oldDeltaY * oldDeltaY <= rangesq) {
if (sceneObject->getCloseObjects() != NULL)
sceneObject->removeInRangeObject(objectToRemove);
if (objectToRemove->getCloseObjects() != NULL)
objectToRemove->removeInRangeObject(sceneObject);
}
}
}
}
//insert new ones
for (int i = 0; i < parentCloseObjects.size(); ++i) {
QuadTreeEntry* o = parentCloseObjects.get(i);
if (sceneObject->getCloseObjects() != NULL)
sceneObject->addInRangeObject(o, false);
if (o->getCloseObjects() != NULL)
o->addInRangeObject(sceneObject, true);
}
}
bool ZoneContainerComponent::removeObject(SceneObject* sceneObject, SceneObject* object, SceneObject* destination, bool notifyClient) {
Zone* zone = dynamic_cast<Zone*>(sceneObject);
if (object->isActiveArea())
return removeActiveArea(zone, dynamic_cast<ActiveArea*>(object));
ManagedReference<SceneObject*> parent = object->getParent();
//SortedVector<ManagedReference<SceneObject*> >* notifiedSentObjects = sceneObject->getNotifiedSentObjects();
try {
Locker locker(object);
if (zone == NULL)
return false;
object->info("removing from zone");
Locker zoneLocker(zone);
if (parent != NULL) {
parent->removeObject(object, NULL, false);
} else
zone->remove(object);
Zone* oldZone = zone;
// oldZone->dropSceneObject(object);
// zoneLocker.release();
SortedVector<ManagedReference<QuadTreeEntry*> >* closeObjects = object->getCloseObjects();
if (closeObjects != NULL) {
try {
while (closeObjects->size() > 0) {
ManagedReference<QuadTreeEntry*> obj = closeObjects->get(0);
if (obj != NULL && obj != object && obj->getCloseObjects() != NULL)
obj->removeInRangeObject(object);
object->removeInRangeObject((int) 0);
}
} catch (...) {
}
} else {
object->info("Null closeobjects vector in ZoneContainerComponent::removeObject", true);
SortedVector<ManagedReference<QuadTreeEntry*> > closeSceneObjects;
zone->getInRangeObjects(object->getPositionX(), object->getPositionY(), 512, &closeSceneObjects, false);
for (int i = 0; i < closeSceneObjects.size(); ++i) {
QuadTreeEntry* obj = closeSceneObjects.get(i);
if (obj != NULL && obj != object && obj->getCloseObjects() != NULL)
obj->removeInRangeObject(object);
}
}
// Zone* oldZone = zone;
zone = NULL;
oldZone->dropSceneObject(object);
SharedBuildingObjectTemplate* objtemplate = dynamic_cast<SharedBuildingObjectTemplate*>(object->getObjectTemplate());
if (objtemplate != NULL) {
String modFile = objtemplate->getTerrainModificationFile();
if (!modFile.isEmpty()) {
oldZone->getPlanetManager()->getTerrainManager()->removeTerrainModification(object->getObjectID());
}
}
zoneLocker.release();
if (object->isTangibleObject()) {
TangibleObject* tano = cast<TangibleObject*>(object);
Vector<ManagedReference<ActiveArea*> >* activeAreas = tano->getActiveAreas();
while (activeAreas->size() > 0) {
Locker _alocker(object->getContainerLock());
ManagedReference<ActiveArea*> area = activeAreas->get(0);
activeAreas->remove(0);
_alocker.release();
area->enqueueExitEvent(object);
}
}
SortedVector<ManagedReference<SceneObject*> >* childObjects = object->getChildObjects();
//Remove all outdoor child objects from zone
for (int i = 0; i < childObjects->size(); ++i) {
ManagedReference<SceneObject*> outdoorChild = childObjects->get(i);
if (outdoorChild == NULL)
continue;
if (outdoorChild->isInQuadTree()) {
Locker locker(outdoorChild);
outdoorChild->destroyObjectFromWorld(true);
}
}
} catch (Exception& e) {
}
object->notifyObservers(ObserverEventType::OBJECTREMOVEDFROMZONE, NULL, 0);
VectorMap<uint32, ManagedReference<Facade*> >* objectActiveSessions = object->getObjectActiveSessions();
while (objectActiveSessions->size()) {
ManagedReference<Facade*> facade = objectActiveSessions->remove(0).getValue();
if (facade == NULL)
continue;
facade->cancelSession();
}
//activeAreas.removeAll();
object->info("removed from zone");
object->notifyRemoveFromZone();
object->setZone(NULL);
return true;
}
void ZoneComponent::destroyObjectFromWorld(SceneObject* sceneObject, bool sendSelfDestroy) {
ManagedReference<SceneObject*> par = sceneObject->getParent();
sceneObject->broadcastDestroy(sceneObject, sendSelfDestroy);
ManagedReference<Zone*> rootZone = sceneObject->getZone();
ManagedReference<Zone*> zone = sceneObject->getLocalZone();
if (par != NULL) {
uint64 parentID = sceneObject->getParentID();
par->removeObject(sceneObject, NULL, false);
if (par->isCellObject()) {
ManagedReference<BuildingObject*> build = cast<BuildingObject*>(par->getParent().get().get());
if (build != NULL) {
CreatureObject* creature = cast<CreatureObject*>(sceneObject);
if (creature != NULL)
build->onExit(creature, parentID);
}
}
sceneObject->notifyObservers(ObserverEventType::OBJECTREMOVEDFROMZONE, sceneObject, 0);
} else if (zone != NULL) {
zone->removeObject(sceneObject, NULL, false);
}
if (rootZone != NULL) {
Locker locker(rootZone);
if (!sceneObject->isActiveArea())
rootZone->remove(sceneObject);
rootZone->dropSceneObject(sceneObject);
SharedBuildingObjectTemplate* objtemplate = dynamic_cast<SharedBuildingObjectTemplate*>(sceneObject->getObjectTemplate());
if (objtemplate != NULL) {
String modFile = objtemplate->getTerrainModificationFile();
if (!modFile.isEmpty()) {
rootZone->getPlanetManager()->getTerrainManager()->removeTerrainModification(sceneObject->getObjectID());
}
}
locker.release();
SortedVector<ManagedReference<QuadTreeEntry*> > closeSceneObjects;
CloseObjectsVector* closeobjects = (CloseObjectsVector*) sceneObject->getCloseObjects();
if (closeobjects != NULL) {
try {
closeobjects->safeCopyTo(closeSceneObjects);
while (closeSceneObjects.size() > 0) {
ManagedReference<QuadTreeEntry*> obj = closeSceneObjects.get(0);
if (obj != NULL && obj != sceneObject && obj->getCloseObjects() != NULL)
obj->removeInRangeObject(sceneObject);
sceneObject->removeInRangeObject((int) 0);
closeSceneObjects.remove((int) 0);
}
closeobjects->removeAll();
} catch (...) {
}
} else {
SortedVector<ManagedReference<QuadTreeEntry*> > closeSceneObjects;
sceneObject->info("Null closeobjects vector in ZoneComponent::destroyObjectFromWorld", true);
rootZone->getInRangeObjects(sceneObject->getPositionX(), sceneObject->getPositionY(), 512, &closeSceneObjects, false);
for (int i = 0; i < closeSceneObjects.size(); ++i) {
QuadTreeEntry* obj = closeSceneObjects.get(i);
if (obj != sceneObject && obj->getCloseObjects() != NULL)
obj->removeInRangeObject(sceneObject);
}
}
// rootZone->dropSceneObject(sceneObject);
// locker.release();
Vector<ManagedReference<ActiveArea*> >* activeAreas = sceneObject->getActiveAreas();
while (activeAreas->size() > 0) {
Locker _alocker(sceneObject->getContainerLock());
ManagedReference<ActiveArea*> area = activeAreas->get(0);
activeAreas->remove(0);
_alocker.release();
area->enqueueExitEvent(sceneObject);
}
}
}
void ZoneComponent::updateZoneWithParent(SceneObject* sceneObject, SceneObject* newParent, bool lightUpdate, bool sendPackets) {
ManagedReference<Zone*> zone = sceneObject->getZone();
ManagedReference<SceneObject*> oldParent = sceneObject->getParent();
if (oldParent != NULL && !oldParent->isCellObject())
return;
if (zone == NULL)
zone = newParent->getRootParent().get()->getZone();
Locker _locker(zone);
if (oldParent == NULL) { // we are in zone, enter cell
//zone->remove(sceneObject);
newParent->transferObject(sceneObject, -1, true);
zone->unlock();
//insertToBuilding(sceneObject, dynamic_cast<BuildingObject*>(newParent->getParent()));
} else { // we are in cell already
if (oldParent != newParent) {
//oldParent->removeObject(sceneObject, false);
newParent->transferObject(sceneObject, -1, true);
zone->unlock();
} else {
zone->unlock();
zone->updateActiveAreas(sceneObject);
}
//notify in range objects that i moved
}
CloseObjectsVector* closeObjects = (CloseObjectsVector*) sceneObject->getCloseObjects();
if (closeObjects != NULL) {
SortedVector<ManagedReference<QuadTreeEntry*> > objects(closeObjects->size(), 10);
closeObjects->safeCopyTo(objects);
for (int i = 0; i < objects.size(); ++i) {
QuadTreeEntry* object = objects.get(i);
try {
object->notifyPositionUpdate(sceneObject);
} catch (Exception& e) {
}
}
}
//zoneLocker.release();
//zone->unlock();
bool isInvis = false;
if (sceneObject->isCreatureObject()) {
CreatureObject* creo = cast<CreatureObject*>(sceneObject);
if(creo->isInvisible())
isInvis = true;
}
if (sendPackets && !isInvis) {
if (lightUpdate) {
LightUpdateTransformWithParentMessage* message = new LightUpdateTransformWithParentMessage(sceneObject);
sceneObject->broadcastMessage(message, false, true);
} else {
UpdateTransformWithParentMessage* message = new UpdateTransformWithParentMessage(sceneObject);
sceneObject->broadcastMessage(message, false, true);
}
}
try {
notifySelfPositionUpdate(sceneObject);
} catch (Exception& e) {
sceneObject->error("Exception caught while calling notifySelfPositionUpdate(sceneObject) in ZoneComponent::updateZoneWithParent");
sceneObject->error(e.getMessage());
}
zone->wlock();
}
