void SpatialIndexManager::initObjectsInRange(PlayerObject* player) {
uint64_t player_id = player->getParentId();
if (player_id == 0) {
return;
}
Object* tmp = gWorldManager->getObjectById(player_id);
if (tmp->getType() != ObjType_Cell) {
return;
}
CellObject* cell = static_cast<CellObject*>(tmp);
tmp = gWorldManager->getObjectById(cell->getParentId());
if (tmp->getType() != ObjType_Building) {
return;
}
BuildingObject* building = static_cast<BuildingObject*>(tmp);
ObjectList children = building->getAllCellChilds();
std::for_each(children.begin(), children.end(), [this, player] (Object* cell_child) {
if (cell_child->getType() != ObjType_Tangible) {
return;
}
sendCreateObject(cell_child, player, true);
});
}
bool SpatialIndexManager::_AddObject(Object *newObject)
{
uint32 finalBucket = getGrid()->AddObject(newObject);
//DLOG(info) << "SpatialIndexManager::AddObject :: Object " << newObject->getId() << " added to bucket " << finalBucket;
if(finalBucket == 0xffffffff) {
DLOG(info) << "SpatialIndexManager::AddObject :: Object " << newObject->getId() << " could not be added to the bucket because the bucket was invalid " << finalBucket;
return false;
}
if(newObject->getType() == ObjType_Player) {
//enforce proper handling of players!!
PlayerObject* player = static_cast<PlayerObject*>(newObject);
_AddObject(player);
}
//get all Players in range and register as necessary
ObjectListType playerList;
getGrid()->GetPlayerViewingRangeCellContents(finalBucket, &playerList);
for(ObjectListType::iterator i = playerList.begin(); i != playerList.end(); i++) {
PlayerObject* otherPlayer = static_cast<PlayerObject*>((*i));
sendCreateObject(newObject,otherPlayer, false);
if((newObject->getType() == ObjType_Creature) || (newObject->getType() == ObjType_NPC)) {
gContainerManager->registerPlayerToContainer(newObject, otherPlayer);
}
}
return true;
}
bool SpatialIndexManager::_AddObject(PlayerObject *player)
{
uint32 finalBucket = getGrid()->AddObject(player);
DLOG(info) << "SpatialIndexManager::AddObject :: Player " << player->getId() << " added to bucket " << finalBucket;
//any errors ?
if(finalBucket == 0xffffffff) {
DLOG(info) << "SpatialIndexManager::AddObject :: Player " << player->getId() << " could not be added to the bucket because the bucket was invalid " << finalBucket;
return false;
}
//now create it for everyone around and around for it
ObjectListType playerList;
getGrid()->GetViewingRangeCellContents(finalBucket, &playerList,(Bucket_Creatures|Bucket_Objects|Bucket_Players));
for(ObjectListType::iterator i = playerList.begin(); i != playerList.end(); i++) {
//we just added ourselves to the grid - dont send a create to ourselves
if(((*i)->getId() == player->getId())) {
continue;
}
//the object needs to be created no matter what
sendCreateObject((*i), player, false);
if(((*i)->getType() == ObjType_Creature) || ((*i)->getType() == ObjType_NPC)) {
gContainerManager->registerPlayerToContainer((*i), player);
continue;
}
if((*i)->getType() == ObjType_Player) {
//create us for the other player
PlayerObject* otherPlayer = static_cast<PlayerObject*>(*i);
sendCreateObject(player, otherPlayer, false);
gContainerManager->registerPlayerToContainer(otherPlayer, player);
continue;
}
}
return true;
}
//======================================================================================================================
//
// create the inventory contents for its owner
//
void MessageLib::sendInventory(PlayerObject* playerObject)
{
if(!_checkPlayer(playerObject))
return;
Inventory* inventory = dynamic_cast<Inventory*>(playerObject->getEquipManager()->getEquippedObject(CreatureEquipSlot_Inventory));
//uint64 parentId = inventory->getParentId();
//to stop the server from crashing.
if(!inventory)
{
assert(false && "MessageLib::sendInventory - Player has no inventory ???? :(");
return;
}
inventory->setTypeOptions(256);
//todo - just use sendcreate tangible and have it send the children, too!!!!
// create the inventory
sendCreateObjectByCRC(inventory,playerObject,false);
sendContainmentMessage(inventory->getId(),inventory->getParentId(),4,playerObject);
sendBaselinesTANO_3(inventory,playerObject);
sendBaselinesTANO_6(inventory,playerObject);
// create objects contained
ObjectIDList* invObjects = inventory->getObjects();
ObjectIDList::iterator objIt = invObjects->begin();
while(objIt != invObjects->end())
{
Object* object = gWorldManager->getObjectById((*objIt));
sendCreateObject(object,playerObject,false);
++objIt;
}
sendEndBaselines(inventory->getId(),playerObject);
ObjectList* invEquippedObjects = playerObject->getEquipManager()->getEquippedObjects();
ObjectList::iterator objEIt = invEquippedObjects->begin();
while(objEIt != invEquippedObjects->end())
{
if(TangibleObject* tangible = dynamic_cast<TangibleObject*>(*objEIt))
{
sendCreateTangible(tangible,playerObject);
}
++objEIt;
}
}
//================================================================================================
// this is called for players and creatures / NPCs alike
//
void SpatialIndexManager::_CheckObjectIterationForCreation(Object* toBeTested, Object* updatedObject)
{
if(toBeTested->getId() == updatedObject->getId()) {
assert(false);
}
//we are a player and need to create the following object for us
if(updatedObject->getType() == ObjType_Player) {
PlayerObject* updatedPlayer = static_cast<PlayerObject*>(updatedObject);
sendCreateObject(toBeTested,updatedPlayer,false);
if(toBeTested->getType() == ObjType_NPC || toBeTested->getType() == ObjType_Creature) {
gContainerManager->registerPlayerToContainer(toBeTested, updatedPlayer);
}
}
if(toBeTested->getType() == ObjType_Player) {
PlayerObject* testedPlayer = static_cast<PlayerObject*> (toBeTested);
sendCreateObject(updatedObject,testedPlayer,false);
gContainerManager->registerPlayerToContainer(updatedObject, testedPlayer);
}
}
//======================================================================================================================
//
// create factory crate
//
bool MessageLib::sendCreateFactoryCrate(FactoryCrate* crate,PlayerObject* targetObject)
{
if(!_checkPlayer(targetObject))
return(false);
sendCreateObjectByCRC(crate,targetObject,false);
uint64 parentId = crate->getParentId();
sendContainmentMessage(crate->getId(),parentId,0xffffffff,targetObject);
sendBaselinesTYCF_3(crate,targetObject);
sendBaselinesTYCF_6(crate,targetObject);
sendBaselinesTYCF_8(crate,targetObject);
sendBaselinesTYCF_9(crate,targetObject);
//check for our linked item and create it
ObjectIDList* ol = crate->getObjects();
ObjectIDList::iterator it = ol->begin();
while(it != ol->end())
{
TangibleObject* tO = dynamic_cast<TangibleObject*>(gWorldManager->getObjectById((*it)));
if(!tO)
{
gLogger->log(LogManager::DEBUG,"Unable to find object with ID %PRIu64", (*it));
continue;
}
//PlayerObject* player = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(targetObject->getId()));
sendCreateObject(tO,targetObject,false);
it++;
}
sendEndBaselines(crate->getId(),targetObject);
//now get the contained tangible and create it
//sendCreateTangible();
return(true);
}
bool SpatialIndexManager::InitializeObject(PlayerObject *player) {
//Pesudo
// 1. Calculate CellID
// 2. Set CellID
// 3. Insert object into the cell in the hash table
//now create around for us
//we have to query the grid as noncontainers must be created to
ObjectListType player_list;
getGrid()->GetViewingRangeCellContents(player->getGridBucket(), &player_list, (Bucket_Creatures|Bucket_Objects|Bucket_Players));
std::for_each(player_list.begin(), player_list.end(), [this, player] (Object* object) {
if (object->getId() == player->getId()) {
return;
}
sendCreateObject(object, player, false);
});
//now building content in case we are in a building
initObjectsInRange(player);
return true;
}
//======================================================================================================================
//
// create tangible
//
bool MessageLib::sendCreateTangible(TangibleObject* tangibleObject,PlayerObject* targetObject, bool sendchildren)
{
if(!_checkPlayer(targetObject))
{
gLogger->log(LogManager::DEBUG,"MessageLib::sendCreateTangible No valid player");
return(false);
}
if(ResourceContainer* resContainer = dynamic_cast<ResourceContainer*>(tangibleObject))
{
return sendCreateResourceContainer(resContainer,targetObject);
}
else if(FactoryCrate* crate = dynamic_cast<FactoryCrate*>(tangibleObject))
{
return sendCreateFactoryCrate(crate,targetObject);
}
else if(tangibleObject->getTangibleGroup() == TanGroup_Static)
{
return sendCreateStaticObject(tangibleObject,targetObject);
}
uint64 parentId = tangibleObject->getParentId();
sendCreateObjectByCRC(tangibleObject,targetObject,false);
if(parentId != 0)
{
// its in a cell, container, inventory
if(parentId != targetObject->getId())
{
// could be inside a crafting tool
Object* parent = gWorldManager->getObjectById(parentId);
CreatureObject* parentObject = dynamic_cast<CreatureObject*>(parent);
if(parent && dynamic_cast<CraftingTool*>(parent))
{
sendContainmentMessage(tangibleObject->getId(),parentId,0,targetObject);
}
// if equipped, also tie it to the object
else if(parentObject)
{
Item* item = dynamic_cast<Item*>(tangibleObject);
sendContainmentMessage(tangibleObject->getId(),parentObject->getId(),4,targetObject);
}
else
{
sendContainmentMessage(tangibleObject->getId(),tangibleObject->getParentId(),0xffffffff,targetObject);
}
}
// or tied directly to an object
else
{
sendContainmentMessage(tangibleObject->getId(),tangibleObject->getParentId(),4,targetObject);
}
}
else
{
sendContainmentMessage(tangibleObject->getId(),tangibleObject->getParentId(),0xffffffff,targetObject);
}
sendBaselinesTANO_3(tangibleObject,targetObject);
sendBaselinesTANO_6(tangibleObject,targetObject);
//now check whether we have children!!!
ObjectIDList* ol = tangibleObject->getObjects();
ObjectIDList::iterator it = ol->begin();
while(it != ol->end())
{
TangibleObject* tO = dynamic_cast<TangibleObject*>(gWorldManager->getObjectById((*it)));
if(!tO)
{
gLogger->log(LogManager::DEBUG,"MessageLib::sendCreateTangible::Unable to find object with ID %PRIu64", (*it));
it++;
continue;
}
PlayerObject* player = dynamic_cast<PlayerObject*>(gWorldManager->getObjectById(targetObject->getId()));
//for children add knownPlayers!!!!
//tO->addKnownObjectSafe(player);
//player->addKnownObjectSafe(tO);
sendCreateObject(tO,player,false);
it++;
}
sendEndBaselines(tangibleObject->getId(),targetObject);
return(true);
}
