void CampTerminalMenuComponent::fillObjectMenuResponse(SceneObject* sceneObject, ObjectMenuResponse* menuResponse, CreatureObject* player) const { if (!sceneObject->isTerminal()) return; Terminal* terminal = cast<Terminal*>(sceneObject); if(terminal == NULL) { error("Terminal is null in fillObjectMenuResponse"); return; } StructureObject* camp = cast<StructureObject*>(terminal->getControlledObject()); if(camp == NULL) { error("Camp is null in fillObjectMenuResponse"); return; } TangibleObjectMenuComponent::fillObjectMenuResponse(sceneObject, menuResponse, player); /// Get Ghost Reference<PlayerObject*> ghost = player->getSlottedObject("ghost").castTo<PlayerObject*>(); if (ghost == NULL) { error("PlayerCreature has no ghost: " + String::valueOf(player->getObjectID())); return; } if (!player->isInRange(terminal, 16)) { return; } menuResponse->addRadialMenuItem(68, 3, "@camp:mnu_status"); /// Make sure player doesn't already have a camp setup somewhere else for (int i = 0; i < ghost->getTotalOwnedStructureCount(); ++i) { uint64 oid = ghost->getOwnedStructure(i); ManagedReference<StructureObject*> structure = ghost->getZoneServer()->getObject(oid).castTo<StructureObject*>(); if (structure == camp) { menuResponse->addRadialMenuItem(182, 3, "@camp:mnu_disband"); return; } } SortedVector<ManagedReference<ActiveArea*> >* areas = camp->getActiveAreas(); ManagedReference<ActiveArea*> area = NULL; for (int i = 0; i < areas->size(); ++i) { area = areas->get(i); if (area->isCampArea()) { break; } area == NULL; } if (area != NULL && area->isCampArea() && (area.castTo<CampSiteActiveArea*>())->isAbandoned()) { menuResponse->addRadialMenuItem(183, 3, "@camp:mnu_assume_ownership"); } }
void CampTerminalMenuComponent::disbandCamp(SceneObject* sceneObject, CreatureObject* player) const { Terminal* terminal = cast<Terminal*>(sceneObject); if(terminal == NULL) { error("Terminal is null in disbandCamp"); return; } if (!player->isInRange(terminal, 16)) { return; } StructureObject* camp = cast<StructureObject*>(terminal->getControlledObject()); if(camp == NULL) { error("Camp is null in disbandCamp"); return; } if (camp->getZone() == NULL) return; PlayerObject* ghost = player->getPlayerObject(); if (ghost == NULL) { return; } if (!ghost->isOwnedStructure(camp)) { return; } if(player->isSitting()) { player->setPosture(CreaturePosture::UPRIGHT, true); } // Find Camp Area SortedVector<ManagedReference<ActiveArea* > >* areas = camp->getActiveAreas(); ManagedReference<ActiveArea*> area = NULL; for(int i = 0; i < areas->size(); ++i) { area = areas->get(i); if(area->isCampArea()) { break; } area == NULL; } CampSiteActiveArea* campArea = cast<CampSiteActiveArea*>(area.get()); if(campArea != NULL && campArea->despawnCamp()) return; StructureManager::instance()->destroyStructure(camp); if(campArea != NULL) { campArea->destroyObjectFromWorld(true); campArea->destroyObjectFromDatabase(true); } }
void DroidMaintenanceModuleDataComponent::payStructures(CreatureObject* player, VectorMap<unsigned long long, int> assignments) { // we know each struct to pay and any fees applied. ManagedReference<DroidObject*> droid = getDroidObject(); for(int i=0;i< assignments.size();i++) { uint64 objectID = assignments.elementAt(i).getKey(); int maintToPay = assignments.elementAt(i).getValue(); ManagedReference<SceneObject*> obj = player->getZoneServer()->getObject(objectID); StructureObject* structureObject = cast<StructureObject*>(obj.get()); if (structureObject != NULL) Locker sLock(obj,player); structureObject->payMaintenance(maintToPay,player,true); } }
void CityRegionImplementation::destroyAllStructuresForRank(uint8 rank, bool sendMail) { Locker locker(_this.getReferenceUnsafeStaticCast()); if (zone == NULL) return; StructureManager* structureManager = StructureManager::instance(); for (int i = structures.size() - 1; i >= 0; --i) { ManagedReference<StructureObject*> structure = structures.get(i); SharedStructureObjectTemplate* ssot = dynamic_cast<SharedStructureObjectTemplate*>(structure->getObjectTemplate()); //We only want to destroy civic structures. if (ssot == NULL || ssot->getCityRankRequired() < rank || !ssot->isCivicStructure()) continue; sendDestroyObjectMail(structure); Locker _clocker(structure, _this.getReferenceUnsafeStaticCast()); structureManager->destroyStructure(structure); structures.removeElement(structure); } for (int i = cityDecorations.size() - 1; i >= 0; --i) { ManagedReference<SceneObject*> decoration = cityDecorations.get(i); StructureObject* structure = decoration.castTo<StructureObject*>(); if (structure == NULL) continue; SharedStructureObjectTemplate* ssot = dynamic_cast<SharedStructureObjectTemplate*>(structure->getObjectTemplate()); //We only want to destroy civic structures. if (ssot == NULL || ssot->getCityRankRequired() < rank || !ssot->isCivicStructure()) continue; sendDestroyObjectMail(structure); Locker _clocker(structure, _this.getReferenceUnsafeStaticCast()); structureManager->destroyStructure(structure); cityDecorations.removeElement(decoration); } }
void CampTerminalMenuComponent::assumeCampOwnership(SceneObject* sceneObject, CreatureObject* player) const { Terminal* terminal = cast<Terminal*>(sceneObject); if(terminal == NULL) { error("Terminal is null in assumeCampOwnership"); return; } if (!player->isInRange(terminal, 16)) { return; } StructureObject* camp = cast<StructureObject*>(terminal->getControlledObject()); if(camp == NULL) { error("Camp is null in assumeCampOwnership"); return; } // Find Camp Area SortedVector<ManagedReference<ActiveArea* > >* areas = camp->getActiveAreas(); ManagedReference<ActiveArea*> area = NULL; for(int i = 0; i < areas->size(); ++i) { area = areas->get(i); if(area->isCampArea()) { break; } area = NULL; } ManagedReference<CampSiteActiveArea*> campArea = cast<CampSiteActiveArea*>(area.get()); if (campArea != NULL) { if(!campArea->isAbandoned()) return; ManagedReference<CreatureObject*> play = player; Core::getTaskManager()->executeTask([=] () { Locker locker(campArea); campArea->assumeOwnership(play); }, "AssumeOwnershipLambda"); } }
void ShuttleInstallationZoneComponent::destroyObjectFromWorld(SceneObject* sceneObject, bool sendSelfDestroy) { if (sceneObject->isStructureObject()) { StructureObject* structureObject = cast<StructureObject*>(sceneObject); ManagedReference<Zone*> zone = sceneObject->getZone(); if (zone != NULL && structureObject->isInstallationObject()) { ManagedReference<InstallationObject*> installationObject = cast<InstallationObject*>(structureObject); if (installationObject->isShuttleInstallation()) { ManagedReference<CityRegion*> cityRegion = structureObject->getCityRegion(); ManagedReference<PlanetManager*> planetManager = zone->getPlanetManager(); if (cityRegion != NULL) { planetManager->removePlayerCityTravelPoint(cityRegion->getRegionName()); Locker clocker(cityRegion, sceneObject); cityRegion->removeShuttleInstallation(); } SortedVector < ManagedReference<SceneObject*> > *childObjects = structureObject->getChildObjects(); ManagedReference<CreatureObject*> shuttle = NULL; for (int i = 0; i < childObjects->size(); ++i) { if (!childObjects->get(i)->isTerminal()) { shuttle = cast<CreatureObject*>(childObjects->get(i).get()); break; } } if (shuttle != NULL) planetManager->removeShuttle(shuttle); } } } ZoneComponent::destroyObjectFromWorld(sceneObject, sendSelfDestroy); }
void DroidMaintenanceModuleDataComponent::getStructureList(Vector<ManagedReference<StructureObject* > >* list,ZoneServer* srv, uint32 planet) { for (int i = 0; i < assignedStructures.size(); i++) { uint64 objectId = assignedStructures.elementAt(i); ManagedReference<SceneObject*> obj = srv->getObject(objectId); if( obj != NULL && obj->isStructureObject() ){ StructureObject* structureObject = cast<StructureObject*>(obj.get()); if( structureObject != NULL ){ // is it on this planet? if (structureObject->getZone()->getZoneCRC() == planet) { list->add(structureObject); } else { if (moduleRating >= 12) // ratign 12 min for interplanetary list->add(structureObject); } } } } }
void ZoneImplementation::addSceneObject(SceneObject* object) { objectMap->put(object->getObjectID(), object); //Civic and commercial structures map registration will be handled by their city if (object->isStructureObject()) { StructureObject* structure = cast<StructureObject*>(object); if (structure->isCivicStructure() || structure->isCommercialStructure()) { return; } //Same thing for player city bank/mission terminals } else if (object->isTerminal()) { Terminal* terminal = cast<Terminal*>(object); ManagedReference<SceneObject*> controlledObject = terminal->getControlledObject(); if (controlledObject != NULL && controlledObject->isStructureObject()) { StructureObject* structure = controlledObject.castTo<StructureObject*>(); if (structure->isCivicStructure()) return; } } registerObjectWithPlanetaryMap(object); }
bool DroidMaintenanceModuleDataComponent::isValidStructure(uint64 objectID){ ManagedReference<DroidObject*> droid = getDroidObject(); if( droid == NULL ) { return false; } ManagedReference<SceneObject*> obj = droid->getZoneServer()->getObject(objectID); if( obj == NULL ) { return false; } if( !obj->isStructureObject() ) { return false; } // we need to check for more than structure we need to check for factories and harvestors as well. StructureObject* structureObject = cast<StructureObject*>(obj.get()); if( structureObject == NULL ) { return false; } ManagedWeakReference< CreatureObject*> linkedCreature = droid->getLinkedCreature(); if( linkedCreature == NULL ) { return false; } if( !structureObject->isOnAdminList( linkedCreature.get() ) ) { return false; } if( structureObject->getZone() == NULL ) { return false; } // All checks passed return true; }
StructureObject* StructureManager::placeStructure(CreatureObject* creature, const String& structureTemplatePath, float x, float y, int angle, int persistenceLevel) { ManagedReference<Zone*> zone = creature->getZone(); if (zone == NULL) return NULL; TerrainManager* terrainManager = zone->getPlanetManager()->getTerrainManager(); SharedStructureObjectTemplate* serverTemplate = dynamic_cast<SharedStructureObjectTemplate*>(templateManager->getTemplate( structureTemplatePath.hashCode())); if (serverTemplate == NULL) { info("server template is null"); return NULL; } float z = zone->getHeight(x, y); float floraRadius = serverTemplate->getClearFloraRadius(); bool snapToTerrain = serverTemplate->getSnapToTerrain(); Reference<StructureFootprint*> structureFootprint = serverTemplate->getStructureFootprint(); float w0 = -5; //Along the x axis. float l0 = -5; //Along the y axis. float l1 = 5; float w1 = 5; float zIncreaseWhenNoAvailableFootprint = 0.f; //TODO: remove this when it has been verified that all buildings have astructure footprint. if (structureFootprint != NULL) { //If the angle is odd, then swap them. getStructureFootprint(serverTemplate, angle, l0, w0, l1, w1); } else { if (!serverTemplate->isCampStructureTemplate()) warning( "Structure with template '" + structureTemplatePath + "' has no structure footprint."); zIncreaseWhenNoAvailableFootprint = 5.f; } if (floraRadius > 0 && !snapToTerrain) z = terrainManager->getHighestHeight(x + w0, y + l0, x + w1, y + l1, 1) + zIncreaseWhenNoAvailableFootprint; String strDatabase = "playerstructures"; bool bIsFactionBuilding = (serverTemplate->getGameObjectType() == SceneObjectType::FACTIONBUILDING); if (bIsFactionBuilding || serverTemplate->getGameObjectType() == SceneObjectType::TURRET) { strDatabase = "playerstructures"; } ManagedReference<SceneObject*> obj = ObjectManager::instance()->createObject( structureTemplatePath.hashCode(), persistenceLevel, strDatabase); if (obj == NULL || !obj->isStructureObject()) { if (obj != NULL) obj->destroyObjectFromDatabase(true); error( "Failed to create structure with template: " + structureTemplatePath); return NULL; } StructureObject* structureObject = cast<StructureObject*>(obj.get()); structureObject->setOwnerObjectID(creature->getObjectID()); structureObject->grantPermission("ADMIN", creature->getFirstName()); structureObject->setOwnerName(creature->getFirstName()); if(structureObject->isTurret() || structureObject->isMinefield()){ structureObject->setFaction(creature->getFaction()); } BuildingObject* buildingObject = NULL; if (structureObject->isBuildingObject()) { buildingObject = cast<BuildingObject*>(structureObject); if (buildingObject != NULL) buildingObject->createCellObjects(); } structureObject->setPublicStructure(serverTemplate->isPublicStructure()); structureObject->initializePosition(x, z, y); structureObject->rotate(angle); //structureObject->insertToZone(zone); zone->transferObject(structureObject, -1, true); structureObject->createChildObjects(); structureObject->notifyStructurePlaced(creature); return structureObject; }
int CampKitMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) { if (!sceneObject->isTangibleObject()) return 0; TangibleObject* tano = cast<TangibleObject*>(sceneObject); if (tano == NULL || !player->isPlayerCreature()) return 0; if (player->getZone() == NULL) return 0; if (!sceneObject->isASubChildOf(player)) return 0; if (selectedID == 20) { /// Get Camp Kit Template CampKitTemplate* campKitData = cast<CampKitTemplate*> (sceneObject->getObjectTemplate()); if (campKitData == NULL) { error("No CampKitTemplate for: " + String::valueOf(sceneObject->getServerObjectCRC())); return 0; } /// Get Camp Template SharedObjectTemplate* templateData = TemplateManager::instance()->getTemplate(campKitData->getSpawnObjectTemplate().hashCode()); CampStructureTemplate* campStructureData = cast<CampStructureTemplate*> (templateData); if (campStructureData == NULL) { error("No CampStructureTemplate for: " + campKitData->getSpawnObjectTemplate()); return 0; } ManagedReference<ZoneServer*> zoneServer = player->getZoneServer(); if (zoneServer == NULL) { error("ZoneServer is null when trying to create camp"); return 0; } ManagedReference<Zone*> zone = player->getZone(); if (zone == NULL) { error("Zone is null when trying to create camp"); return 0; } ManagedReference<PlanetManager*> planetManager = zone->getPlanetManager(); if (planetManager == NULL) { error("Unable to get PlanetManager when placing camp"); return 0; } /// Get Ghost Reference<PlayerObject*> ghost = player->getSlottedObject("ghost").castTo<PlayerObject*>(); if (ghost == NULL) { error("PlayerCreature has no ghost: " + String::valueOf(player->getObjectID())); return 0; } int playerSkill = player->getSkillMod("camp"); if(playerSkill < campStructureData->getSkillRequired()) { player->sendSystemMessage("@camp:sys_nsf_skill"); return 0; } if(player->isInCombat()) { player->sendSystemMessage("@camp:sys_not_in_combat"); return 0; } if(player->getParent() != NULL && player->getParent().get()->isCellObject()) { player->sendSystemMessage("@camp:error_inside"); return 0; } if(!sceneObject->isASubChildOf(player)) { player->sendSystemMessage("@camp:sys_not_in_inventory"); return 0; } if(!player->isStanding() || player->isRidingMount()) { player->sendSystemMessage("@camp:error_cmd_fail"); return 0; } ManagedReference<CityRegion*> region = player->getCityRegion(); if(region != NULL) { player->sendSystemMessage("@camp:error_muni_true"); return 0; } /// Check for water if(player->isSwimming() || player->isInWater()) { player->sendSystemMessage("@camp:error_in_water"); return 0; } /// Make sure player doesn't already have a camp setup somewhere else for (int i = 0; i < ghost->getTotalOwnedStructureCount(); ++i) { uint64 oid = ghost->getOwnedStructure(i); ManagedReference<StructureObject*> structure = ghost->getZoneServer()->getObject(oid).castTo<StructureObject*>(); if (structure != NULL && structure->isCampStructure()) { player->sendSystemMessage("@camp:sys_already_camping"); return 0; } } /// Check if player is in another camp if(player->getCurrentCamp() != NULL) { player->sendSystemMessage("@camp:error_camp_exists"); return 0; } /// Check if player is elevated, on a building or porch /// Check camps/lairs nearby SortedVector<ManagedReference<QuadTreeEntry* > > nearbyObjects; zone->getInRangeObjects(player->getPositionX(), player->getPositionY(), 512, &nearbyObjects, true); for(int i = 0; i < nearbyObjects.size(); ++i) { SceneObject* scno = cast<SceneObject*>(nearbyObjects.get(i).get()); if (scno != NULL && scno->isCampStructure() && scno->getDistanceTo( player) <= scno->getObjectTemplate()->getNoBuildRadius() + campStructureData->getRadius()) { player->sendSystemMessage("@camp:error_camp_too_close"); return 0; } if (scno != NULL && !scno->isCampStructure() && scno->isStructureObject() && scno->getDistanceTo(player) <= 100) { player->sendSystemMessage("@camp:error_building_too_close"); return 0; } if(scno != NULL && scno->getDistanceTo(player) <= scno->getObjectTemplate()->getNoBuildRadius() + campStructureData->getRadius()) { if (scno->getObserverCount(ObserverEventType::OBJECTDESTRUCTION) > 0) { SortedVector<ManagedReference<Observer* > > observers = scno->getObservers(ObserverEventType::OBJECTDESTRUCTION); for(int j = 0; j < observers.size(); ++j) { if(observers.get(j)->isObserverType(ObserverType::LAIR)) { player->sendSystemMessage("@camp:error_lair_too_close"); return 0; } } } if (scno->getObserverCount(ObserverEventType::CREATUREDESPAWNED) > 0) { SortedVector<ManagedReference<Observer* > > observers2 = scno->getObservers(ObserverEventType::CREATUREDESPAWNED); for(int j = 0; j < observers2.size(); ++j) { if(observers2.get(j)->isObserverType(ObserverType::LAIR)) { player->sendSystemMessage("@camp:error_lair_too_close"); return 0; } } } } } /// Check to see if you can camp here (Allows building in city no-build zone but not within city limits which are checked above) if (!planetManager->isCampingPermittedAt(player->getPositionX(), player->getPositionY(), campStructureData->getRadius())) { player->sendSystemMessage("@camp:error_nobuild"); return 0; } player->sendSystemMessage("@camp:starting_camp"); /// Create Structure StructureObject* structureObject = StructureManager::instance()->placeStructure( player, campKitData->getSpawnObjectTemplate(), player->getPositionX(), player->getPositionY(), (int) player->getDirectionAngle()); if (structureObject == NULL) { error("Unable to create camp: " + campKitData->getSpawnObjectTemplate()); return 1; } /// Identify terminal for Active area Terminal* campTerminal = NULL; SortedVector < ManagedReference<SceneObject*> > *childObjects = structureObject->getChildObjects(); for (int i = 0; i < childObjects->size(); ++i) { if (childObjects->get(i)->isTerminal()) { campTerminal = cast<Terminal*> (childObjects->get(i).get()); break; } } if (campTerminal == NULL) { structureObject->destroyObjectFromDatabase(true); error("Camp does not have terminal: " + campStructureData->getTemplateFileName()); return 1; } String campName = player->getFirstName(); if(!player->getLastName().isEmpty()) campName += " " + player->getLastName(); campName += "'s Camp"; campTerminal->setCustomObjectName(campName, true); /// Create active area String areaPath = "object/camp_area.iff"; ManagedReference<CampSiteActiveArea*> campArea = (zoneServer->createObject( areaPath.hashCode(), 1)).castTo< CampSiteActiveArea*>(); if (campArea == NULL) { structureObject->destroyObjectFromDatabase(true); return 1; } Locker areaLocker(campArea, player); campArea->init(campStructureData); campArea->setTerminal(campTerminal); campArea->setCamp(structureObject); campArea->setOwner(player); campArea->setNoBuildArea(true); campArea->initializePosition(player->getPositionX(), 0, player->getPositionY()); if (!zone->transferObject(campArea, -1, false)) { structureObject->destroyObjectFromDatabase(true); campArea->destroyObjectFromDatabase(true); return 1; } structureObject->addActiveArea(campArea); player->sendSystemMessage("@camp:camp_complete"); /// Remove Camp TangibleObject* tano = cast<TangibleObject*>(sceneObject); if(tano != NULL) tano->decreaseUseCount(); return 0; } else return TangibleObjectMenuComponent::handleObjectMenuSelect(sceneObject, player, selectedID); return 0; }
void CityRegionImplementation::notifyExit(SceneObject* object) { //pre: no 2 different city regions should ever overlap, only 2 Regions of the same city region if (object->isTangibleObject()) { TangibleObject* tano = cast<TangibleObject*>(object); ManagedReference<Region*> activeRegion = tano->getActiveRegion().castTo<Region*>(); if (activeRegion != NULL) { ManagedReference<CityRegion*> city = activeRegion->getCityRegion(); object->setCityRegion(city); if (city == _this.getReferenceUnsafeStaticCast()) // if its the same city we wait till the object exits the last region return; } else { object->setCityRegion(NULL); } } else { object->setCityRegion(NULL); } if (object->isBazaarTerminal() || object->isVendor()) { if (object->isBazaarTerminal()) bazaars.drop(object->getObjectID()); AuctionTerminalDataComponent* terminalData = NULL; DataObjectComponentReference* data = object->getDataObjectComponent(); if(data != NULL && data->get() != NULL && data->get()->isAuctionTerminalData()) terminalData = cast<AuctionTerminalDataComponent*>(data->get()); if(terminalData != NULL) terminalData->updateUID(); } if (object->isPlayerCreature()) currentPlayers.decrement(); if (isClientRegion()) return; if (object->isCreatureObject()) { CreatureObject* creature = cast<CreatureObject*>(object); StringIdChatParameter params("city/city", "city_leave_city"); //You have left %TO. params.setTO(getRegionName()); creature->sendSystemMessage(params); removeSpecializationModifiers(creature); } if (object->isStructureObject()) { float x = object->getWorldPositionX(); float y = object->getWorldPositionY(); StructureObject* structure = cast<StructureObject*>(object); Locker slocker(&structureListMutex); if (structure->isBuildingObject()) { BuildingObject* building = cast<BuildingObject*>(object); uint64 ownerID = structure->getOwnerObjectID(); ZoneServer* zoneServer = building->getZoneServer(); if (zoneServer != NULL) { ManagedReference<CreatureObject*> owner = zoneServer->getObject(ownerID).castTo<CreatureObject*>(); if(owner != NULL && owner->isPlayerCreature() && building->isResidence() && isCitizen(ownerID)) { CityManager* cityManager = zoneServer->getCityManager(); cityManager->unregisterCitizen(_this.getReferenceUnsafeStaticCast(), owner); } } } completeStructureList.drop(structure->getObjectID()); if (structure->isCivicStructure()) { removeStructure(structure); } else if (structure->isCommercialStructure()) { removeCommercialStructure(structure); } } if (object->isDecoration() && object->getParent().get() == NULL) { removeDecoration(object); } }
void CityRegionImplementation::notifyEnter(SceneObject* object) { if (object->getCityRegion().get() != _this.getReferenceUnsafeStaticCast() && object->isPlayerCreature()) currentPlayers.increment(); object->setCityRegion(_this.getReferenceUnsafeStaticCast()); if (object->isBazaarTerminal() || object->isVendor()) { if (object->isBazaarTerminal()) bazaars.put(object->getObjectID(), cast<TangibleObject*>(object)); AuctionTerminalDataComponent* terminalData = NULL; DataObjectComponentReference* data = object->getDataObjectComponent(); if(data != NULL && data->get() != NULL && data->get()->isAuctionTerminalData()) terminalData = cast<AuctionTerminalDataComponent*>(data->get()); if(terminalData != NULL) terminalData->updateUID(); } if (isClientRegion()) return; if (object->isCreatureObject()) { CreatureObject* creature = cast<CreatureObject*>(object); StringIdChatParameter params("city/city", "city_enter_city"); //You have entered %TT (%TO). params.setTT(getRegionName()); UnicodeString strRank = StringIdManager::instance()->getStringId(String("@city/city:rank" + String::valueOf(cityRank)).hashCode()); if (citySpecialization.isEmpty()) { params.setTO(strRank); } else { UnicodeString citySpec = StringIdManager::instance()->getStringId(citySpecialization.hashCode()); params.setTO(strRank + ", " + citySpec); } creature->sendSystemMessage(params); applySpecializationModifiers(creature); } if (object->isStructureObject()) { StructureObject* structure = cast<StructureObject*>(object); CityManager* cityManager = getZone()->getZoneServer()->getCityManager(); Locker slocker(&structureListMutex); if (isLoaded() && !completeStructureList.contains(structure->getObjectID()) && structure->getBaseMaintenanceRate() > 0) { cityManager->sendAddStructureMails(_this.getReferenceUnsafeStaticCast(), structure); } if (structure->isBuildingObject()) { BuildingObject* building = cast<BuildingObject*>(object); uint64 ownerID = structure->getOwnerObjectID(); ManagedReference<CreatureObject*> owner = zone->getZoneServer()->getObject(ownerID).castTo<CreatureObject*>(); if(owner != NULL && owner->isPlayerCreature() && building->isResidence() && !isCitizen(ownerID)) { cityManager->registerCitizen(_this.getReferenceUnsafeStaticCast(), owner); } } completeStructureList.put(structure->getObjectID()); if (structure->isCivicStructure() && !structure->isDecoration()) { addStructure(structure); } else if (structure->isCommercialStructure()) { addCommercialStructure(structure); } if (registered) { zone->registerObjectWithPlanetaryMap(structure); } } if (object->isDecoration() && object->getParent().get() == NULL) { addDecoration(object); } if (registered && cityMissionTerminals.contains(object)) { zone->registerObjectWithPlanetaryMap(object); } if (!registered && citySkillTrainers.contains(object)) { zone->unregisterObjectWithPlanetaryMap(object); } }
void CampTerminalMenuComponent::showCampStatus(SceneObject* sceneObject, CreatureObject* player) const { Terminal* terminal = cast<Terminal*>(sceneObject); if(terminal == NULL) { error("Terminal is null in CampTerminalMenuComponent::showCampStatus"); return; } if (!player->isInRange(terminal, 16)) { return; } StructureObject* camp = cast<StructureObject*>(terminal->getControlledObject()); if(camp == NULL) { error("Camp is null in CampTerminalMenuComponent::showCampStatus"); return; } // Get Camp Area SortedVector<ManagedReference<ActiveArea* > >* areas = camp->getActiveAreas(); ManagedReference<ActiveArea*> area = NULL; for(int i = 0; i < areas->size(); ++i) { area = areas->get(i); if(area->isCampArea()) { break; } area = NULL; } if(area == NULL) { Reference<StructureManager*> structureManager = StructureManager::instance(); if (structureManager == NULL) { error("Unable to get StructureManager in CampTerminalMenuComponent::showCampStatus"); return; } structureManager->destroyStructure(camp); player->sendSystemMessage("This camp is broken, removing from world. Thanks!"); error("CampSiteActiveArea is null in CampTerminalMenuComponent::showCampStatus"); return; } CampSiteActiveArea* campArea = cast<CampSiteActiveArea*>(area.get()); if(campArea == NULL) { error("How the f**k did this happen"); return; } /// Get Ghost Reference<PlayerObject*> ghost = player->getSlottedObject("ghost").castTo<PlayerObject*>(); if (ghost == NULL) { error("PlayerCreature has no ghost in CampTerminalMenuComponent::showCampStatus: " + String::valueOf(player->getObjectID())); return; } ManagedReference<SuiListBox*> suiBox = new SuiListBox(player, SuiWindowType::CAMP_STATUS); suiBox->setPromptTitle("@camp:mnu_status"); suiBox->setUsingObject(terminal); suiBox->setPromptText(terminal->getDisplayedName()); StringBuffer owner, time, visitors; owner << "Owner: " << campArea->getOwner()->getFirstName() << " " << camp->getOwnerCreatureObject()->getLastName() << endl; suiBox->addMenuItem(owner.toString()); time << "Time: " << (campArea->getUptime() / 60) << " minutes, "<< (campArea->getUptime() % 60) << "seconds"; suiBox->addMenuItem(time.toString()); visitors << "Visitors: " << campArea->getVisitorCount() << endl; suiBox->addMenuItem(visitors.toString()); ghost->addSuiBox(suiBox); player->sendMessage(suiBox->generateMessage()); }
int DroidMaintenanceModuleDataComponent::handleObjectMenuSelect(CreatureObject* player, byte selectedID, PetControlDevice* controller) { ManagedReference<DroidObject*> droid = getDroidObject(); if( droid == NULL ){ info( "Droid is null"); return 0; } Locker dlock( droid, player ); // Perform Maintenance Run if( selectedID == MAINT_MODULE_PERFORM ){ // Init Maintenance Run Session //droid->getCooldownTimerMap()->updateToCurrentAndAddMili("Droid_Cooldown",1800000); // Interplanetary Time + 1 hour 40 minutes, 33 seconds // Local time: distance < 432 == 15 mins + (1s per 3 meters to next structure for that planet @ < 432m from first structure) // Local time: distance > 432 == 48 minutes 20 seconds // Start a session for the player and this module! ManagedReference<DroidMaintenanceSession*> session = new DroidMaintenanceSession(this, player); session->initialize(); player->addActiveSession(SessionFacadeType::DROIDMAINTENANCERUN, session); session->sendMaintanceRunBox(); return 0; } // Edit Maintenance List else if( selectedID == MAINT_MODULE_EDIT ){ if( assignedStructures.isEmpty() ){ player->sendSystemMessage( "@pet/droid_modules:droid_maint_empty_list" ); // The maintenance list for this droid is empty. Go to one of your structures and assign this droid to maintain it. return 0; } // Build List of Assigned Structures ManagedReference<SuiListBox*> box = new SuiListBox(player, SuiWindowType::DROID_EDIT_ASSIGNED_STRUCTURES, SuiListBox::HANDLETWOBUTTON); box->setCallback(new RemoveDroidStructureSuiCallback(player->getZoneServer(), this)); box->setPromptTitle("@pet/droid_modules:droid_maint_edit_title"); // Edit Maintenance List box->setPromptText("@pet/droid_modules:droid_maint_edit_prompt"); // Please select a structure to remove from this droid's maintenance list. box->setOkButton(true, "@delete"); box->setCancelButton(true, "@cancel"); for (int i = 0; i < assignedStructures.size(); i++) { uint64 objectId = assignedStructures.elementAt(i); ManagedReference<SceneObject*> obj = player->getZoneServer()->getObject(objectId); if( obj != NULL && obj->isStructureObject() ){ StructureObject* structureObject = cast<StructureObject*>(obj.get()); if( structureObject != NULL ){ box->addMenuItem( structureObject->getDisplayedName(), objectId ); } } } box->setUsingObject(droid); player->getPlayerObject()->addSuiBox(box); player->sendMessage(box->generateMessage()); } return 0; }