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;
}
