int DestroyStructureSessionImplementation::destroyStructure() {
creatureObject->sendSystemMessage("@player_structure:processing_destruction"); //Processing confirmed structure destruction...
if (structureObject == NULL || structureObject->getZone() == NULL)
return cancelSession();
if (structureObject->isGCWBase()) {
Zone* zone = structureObject->getZone();
if (zone == NULL)
return cancelSession();
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan == NULL)
return cancelSession();
gcwMan->doBaseDestruction(structureObject);
return cancelSession();
} else if(structureObject->isTurret() || structureObject->isMinefield()){
Reference<DestroyFactionInstallationTask*> destroyTask = new DestroyFactionInstallationTask(cast<InstallationObject*>(structureObject.get()));
destroyTask->execute();
return cancelSession();
} else {
StructureManager::instance()->redeedStructure(creatureObject);
}
return 0;
}
void TurretControlMenuComponent::fillObjectMenuResponse(SceneObject* sceneObject, ObjectMenuResponse* menuResponse, CreatureObject* player) {
ManagedReference<BuildingObject*> building = cast<BuildingObject*>(sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).get().get());
ManagedReference<PlayerObject*> thisPlayer = player->getPlayerObject();
if ( thisPlayer == NULL || building == NULL || player->isDead() || player->isIncapacitated())
return;
if(player->getFaction() == 0)
player->sendSystemMessage("@faction_recruiter:must_be_declared_use"); // Your faction affiliation must be delcared in order to use that item.
Zone* zone = building->getZone();
if(zone == NULL)
return;
GCWManager* gcwMan = zone->getGCWManager();
if(!gcwMan->canUseTerminals(player, building, sceneObject))
return;
if(building->getFaction() == player->getFaction() && player->getFaction() != 0) {
menuResponse->addRadialMenuItem(222, 3, "@hq:mnu_turret_control"); // "Turret Control"
}
//menuResponse->addRadialMenuItem(222, 3, "OH YEA");
}
void PowerRegulatorMenuComponent::fillObjectMenuResponse(SceneObject* sceneObject, ObjectMenuResponse* menuResponse, CreatureObject* player) const {
ManagedReference<BuildingObject*> building = sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).castTo<BuildingObject*>();
if (building == NULL)
return;
if (player == NULL || player->isDead() || player->isIncapacitated())
return;
Zone* zone = building->getZone();
if (zone == NULL)
return;
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan == NULL)
return;
if (!gcwMan->isBaseVulnerable(building))
return;
menuResponse->addRadialMenuItem(20, 3, "@hq:mnu_set_overload"); // Set to overload
}
void PowerRegulatorMenuComponent::fillObjectMenuResponse(SceneObject* sceneObject, ObjectMenuResponse* menuResponse, CreatureObject* player) {
ManagedReference<BuildingObject*> building = cast<BuildingObject*>(sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).get().get());
if (building == NULL)
return;
if (player == NULL || player->isDead() || player->isIncapacitated())
return;
Zone* zone = building->getZone();
if (zone == NULL)
return;
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan == NULL)
return;
if (!gcwMan->canUseTerminals(player, building, sceneObject))
return;
if (gcwMan->isDNASampled(building) && !gcwMan->isPowerOverloaded(building) && player->getFaction() != building->getFaction()) {
menuResponse->addRadialMenuItem(228, 3, "@hq:mnu_set_overload"); // Set to overload
}
}
void UplinkTerminalMenuComponent::fillObjectMenuResponse(SceneObject* sceneObject, ObjectMenuResponse* menuResponse, CreatureObject* player) {
ManagedReference<BuildingObject*> building = cast<BuildingObject*>(sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).get().get());
if (building == NULL || player->isDead() || player->isIncapacitated())
return;
Zone* zone = building->getZone();
if (zone == NULL)
return;
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan == NULL)
return;
if (!gcwMan->canUseTerminals(player, building, sceneObject))
return;
if (building->getFaction() != player->getFaction()) {
if (gcwMan->isBaseVulnerable(building) && !gcwMan->isUplinkJammed(building)) {
menuResponse->addRadialMenuItem(227, 3, "@hq:mnu_jam");
}
}
}
int TurretControlMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) {
if (sceneObject == NULL || !sceneObject->isTangibleObject() || player == NULL)
return 0;
ManagedReference<PlayerObject*> ghost = player->getPlayerObject();
if (ghost == NULL)
return 1;
ManagedReference<BuildingObject*> building = cast<BuildingObject*>(sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).get().get());
if(building == NULL)
return 1;
Zone* zone = building->getZone();
if(zone == NULL)
return 1;
ManagedReference<GCWManager*> gcwMan = zone->getGCWManager();
if(gcwMan == NULL)
return 1;
if(!gcwMan->canUseTerminals(player, building, sceneObject))
return 1;
if(selectedID == 222){
gcwMan->sendTurretAttackListTo(player,sceneObject);
}
return 0;
}
int PowerRegulatorMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) {
if (player->isDead() || player->isIncapacitated())
return 1;
ManagedReference<BuildingObject*> building = cast<BuildingObject*>(sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).get().get());
ManagedReference<TangibleObject*> powerRegulator = cast<TangibleObject*>(sceneObject);
if (building == NULL)
return 1;
Zone* zone = building->getZone();
if (zone == NULL)
return 1;
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan == NULL)
return 1;
if (!gcwMan->canUseTerminals(player, building, sceneObject))
return 1;
if (player->getFaction() != building->getFaction()) {
if (selectedID == 228 || selectedID == 20) {
if (player->hasSkill("combat_commando_heavyweapon_speed_02"))
gcwMan->sendPowerRegulatorControls(player, building, powerRegulator);
else
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:commando_only"); // Only an experienced commando with heavy weapons training could expect to rig the regulators for overload
}
}
return 0;
}
void HQMenuComponent::fillObjectMenuResponse(SceneObject* sceneObject, ObjectMenuResponse* menuResponse, CreatureObject* player) {
ManagedReference<BuildingObject*> building = cast<BuildingObject*>(sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).get().get());
if (building == NULL)
return;
if ( player == NULL || player->isDead() || player->isIncapacitated())
return;
Zone* zone = building->getZone();
if(zone == NULL)
return;
GCWManager* gcwMan = zone->getGCWManager();
if(!gcwMan->canUseTerminals(player, building, sceneObject))
return;
if(building->getFaction() == player->getFaction()) {
menuResponse->addRadialMenuItem(228, 3, "@hq:mnu_defense_status");
if(gcwMan->isShutdownSequenceStarted(building) && building->getPvpStatusBitmask() && CreatureFlag::OVERT){
menuResponse->addRadialMenuItem(231, 3, "@hq:mnu_shutdown"); // Shutdown facility
}
// donate menus removed
menuResponse->addRadialMenuItem(37, 3, "@hq:mnu_donate"); // Donate
//menuResponse->addRadialMenuItemToRadialID(37, 225, 3, "@hq:mnu_donate_money"); // Donate MOney
menuResponse->addRadialMenuItemToRadialID(37, 226, 3, "@hq:mnu_donate_deed"); // donate defense
if(building->getOwnerCreatureObject() == player && building->getPvpStatusBitmask() & CreatureFlag::OVERT){
menuResponse->addRadialMenuItem(38, 3, "@hq:mnu_reset_vulnerability"); // Reset Vulnerability
}
} else {
if(gcwMan->isPowerOverloaded(building) && !gcwMan->isShutdownSequenceStarted(building)){
menuResponse->addRadialMenuItem(230, 3, "@hq:mnu_overload"); // activate overload
}
}
// Admin menus to test out vulnerability manually
/*
if ( player->getPlayerObject()->isPrivileged()) {
//info("player is privelaged", true);
menuResponse->addRadialMenuItem(35, 3, "PVP EVENT");
menuResponse->addRadialMenuItemToRadialID(35, MAKEIMPERIAL, 3, "MAKE VULNERABLE");
menuResponse->addRadialMenuItemToRadialID(35, MAKENEUTRAL, 3, "MAKE INVULNERABLE");
}
*/
//menuResponse->addRadialMenuItem(229, 3, "@player_structure:permission_destroy"); //Destroy Structure
}
int PowerRegulatorMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) const {
if (player->isDead() || player->isIncapacitated() || selectedID != 20)
return 1;
ManagedReference<BuildingObject*> building = sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).castTo<BuildingObject*>();
ManagedReference<TangibleObject*> powerRegulator = cast<TangibleObject*>(sceneObject);
if (building == NULL)
return 1;
Zone* zone = building->getZone();
if (zone == NULL)
return 1;
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan == NULL)
return 1;
if (!gcwMan->isBaseVulnerable(building))
return 1;
if (!gcwMan->areOpposingFactions(player->getFaction(), building->getFaction())) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:no_tamper"); // You are not an enemy of this structure. Why would you want to tamper?
return 1;
} else if (gcwMan->isPowerOverloaded(building)) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:already_overloading"); // The power regulator has already been set to overload.
return 1;
} else if (!gcwMan->isDNASampled(building)) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:other_objectives"); // Other objectives must be disabled prior to gaining access to this one.
return 1;
} else if (player->isInCombat()) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:power_not_in_combat"); // You cannot align the power flow to overload if you are in combat!
return 1;
} else if (powerRegulator->getParentID() != player->getParentID()) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:power_not_in_room"); // You cannot align the power flow if you are not even in the same room!
return 1;
} else if (powerRegulator->getDistanceTo(player) > 15) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:power_too_far"); // You are too far away from the power regulator to continue the setup!
return 1;
} else if (!player->hasSkill("combat_commando_heavyweapon_speed_02")) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:commando_only"); // Only an experienced commando with heavy weapons training could expect to rig the regulators for overload
return 1;
}
Reference<CreatureObject*> playerRef = player;
Core::getTaskManager()->executeTask([=] () {
Locker locker(playerRef);
Locker clocker(building, playerRef);
gcwMan->sendPowerRegulatorControls(playerRef, building, powerRegulator);
}, "SendPowerRegulatorControlsLambda");
return 0;
}
void SlicingSessionImplementation::handleSlice(SuiListBox* suiBox) {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (player == NULL || tangibleObject == NULL)
return;
Locker locker(player);
Locker clocker(tangibleObject, player);
PlayerManager* playerManager = player->getZoneServer()->getPlayerManager();
suiBox->removeAllMenuItems();
suiBox->setCancelButton(false,"@cancel");
StringBuffer prompt;
prompt << "@slicing/slicing:";
prompt << getPrefix(tangibleObject) + "examine";
suiBox->setPromptText(prompt.toString());
player->getPlayerObject()->addSuiBox(suiBox);
player->sendMessage(suiBox->generateMessage());
if (tangibleObject->isContainerObject() || tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE) {
handleContainerSlice();
playerManager->awardExperience(player, "slicing", 125, true); // Container Slice XP
} else if (tangibleObject->isMissionTerminal()) {
MissionTerminal* term = cast<MissionTerminal*>( tangibleObject.get());
playerManager->awardExperience(player, "slicing", 250, true); // Terminal Slice XP
term->addSlicer(player);
player->sendSystemMessage("@slicing/slicing:terminal_success");
} else if (tangibleObject->isWeaponObject()) {
handleWeaponSlice();
playerManager->awardExperience(player, "slicing", 500, true); // Weapon Slice XP
} else if (tangibleObject->isArmorObject()) {
handleArmorSlice();
playerManager->awardExperience(player, "slicing", 1000, true); // Armor Slice XP
} else if ( isBaseSlice()){
playerManager->awardExperience(player,"slicing", 1000, true); // Base slicing
Zone* zone = player->getZone();
if(zone != NULL){
GCWManager* gcwMan = zone->getGCWManager();
if(gcwMan != NULL){
SecuritySliceTask* task = new SecuritySliceTask(gcwMan, tangibleObject.get(), player);
task->execute();
}
}
}
endSlicing();
}
void SlicingSessionImplementation::handleSliceFailed() {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (tangibleObject == NULL || player == NULL)
return;
if (tangibleObject->isMissionTerminal())
player->sendSystemMessage("@slicing/slicing:terminal_fail");
else if (tangibleObject->isWeaponObject())
player->sendSystemMessage("@slicing/slicing:fail_weapon");
else if (tangibleObject->isArmorObject())
player->sendSystemMessage("@slicing/slicing:fail_armor");
else if (tangibleObject->isContainerObject() || tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE)
player->sendSystemMessage("@slicing/slicing:container_fail");
else if (isBaseSlice())
player->sendSystemMessage("@slicing/slicing:hq_security_fail"); // Unable to sucessfully slice the terminal, you realize that the only away
else
player->sendSystemMessage("Your attempt to slice the object has failed.");
if (tangibleObject->isContainerObject()) {
ManagedReference<Container*> container = tangibleObject.castTo<Container*>();
Locker clocker(container, player);
if(!container)
return;
container->setSliced(true);
if(!container->isRelocking())
{
relockEvent = new RelockLootContainerEvent(container);
relockEvent->schedule(container->getLockTime()); // This will reactivate the 'broken' lock. (1 Hour)
}
} else if (isBaseSlice()){
Zone* zone = player->getZone();
if(zone != NULL){
GCWManager* gcwMan = zone->getGCWManager();
if(gcwMan != NULL)
gcwMan->failSecuritySlice(tangibleObject.get());
}
} else if (!tangibleObject->isMissionTerminal()) {
tangibleObject->setSliced(true);
}
endSlicing();
}
int HQMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* creature, byte selectedID) {
if (creature->isDead() || creature->isIncapacitated())
return 1;
ManagedReference<BuildingObject*> building = cast<BuildingObject*>(sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).get().get());
if(building == NULL)
return 1;
Zone* zone = building->getZone();
if(zone == NULL)
return 1;
ManagedReference<GCWManager*> gcwMan = zone->getGCWManager();
if(gcwMan == NULL)
return 1;
if(!gcwMan->canUseTerminals(creature, building, sceneObject))
return 1;
if(creature->getFaction() == building->getFaction()) {
if (selectedID == 20){
gcwMan->sendStatus(building,creature);
} else if( selectedID == 228 || selectedID == 20){
gcwMan->sendBaseDefenseStatus(creature, building);
} else if ( selectedID == 38) {
gcwMan->sendResetVerification(creature, building);
} else if(selectedID == 231) {
ShutdownSequenceTask* task = new ShutdownSequenceTask(gcwMan, building, creature, false);
task->execute();
} else if (selectedID == 226)
gcwMan->sendSelectDeedToDonate(building,creature,0);
} else {
if ( selectedID == 230 ) {
if(creature->hasSkill("outdoors_squadleader_novice")) {
ShutdownSequenceTask* task = new ShutdownSequenceTask(gcwMan, building, creature, true);
task->execute();
} else
creature->sendSystemMessage(("@faction/faction_hq/faction_hq_response:terminal_response03")); // only an experienced squad leader could expect to coordinate a reactor overload
} else if ( selectedID == 20) {
if(creature->getFactionRank() >= 9) {
gcwMan->sendStatus(building,creature);
} else {
creature->sendSystemMessage("You must be at least a Warrant Officer in order to use this terminal");
}
}
}
return 0;
}
int TurretDataComponent::getAutoFireTimeout() {
int cooldown = 20;
ManagedReference<InstallationObject*> turret = cast<InstallationObject*>(getParent());
if (turret != NULL) {
Zone* zone = turret->getZone();
if (zone != NULL) {
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan != NULL)
cooldown = gcwMan->getTurretAutoFireTimeout();
}
}
return cooldown;
}
int UplinkTerminalMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) {
if (sceneObject == NULL || !sceneObject->isTangibleObject() || player == NULL || player->isDead() || player->isIncapacitated())
return 0;
ManagedReference<BuildingObject*> building = cast<BuildingObject*>(sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).get().get());
ManagedReference<TangibleObject*> uplinkTerminal = cast<TangibleObject*>(sceneObject);
if (building == NULL)
return 1;
Zone* zone = sceneObject->getZone();
if (zone == NULL)
return 1;
ManagedReference<GCWManager*> gcwMan = zone->getGCWManager();
if (gcwMan == NULL)
return 1;
if (!gcwMan->canUseTerminals(player, building, sceneObject))
return 1;
if (selectedID == 227 || selectedID == 20) {
if (player->getFaction() != building->getFaction()) {
if (player->hasSkill("combat_bountyhunter_investigation_02"))
gcwMan->sendJamUplinkMenu(player, building, uplinkTerminal);
else
player->sendSystemMessage("Only an experienced Bounty Hunter with Investigation experience could expect to jam the uplink");
}
}
return 0;
}
void StructureManager::loadPlayerStructures(const String& zoneName) {
info("Loading player structures from playerstructures.db");
ObjectDatabaseManager* dbManager = ObjectDatabaseManager::instance();
ObjectDatabase* playerStructuresDatabase =
ObjectDatabaseManager::instance()->loadObjectDatabase(
"playerstructures", true);
if (playerStructuresDatabase == NULL) {
error("Could not load the player structures database.");
return;
}
int i = 0;
try {
ObjectDatabaseIterator iterator(playerStructuresDatabase);
uint64 objectID;
ObjectInputStream* objectData = new ObjectInputStream(2000);
String zoneReference;
while (iterator.getNextKeyAndValue(objectID, objectData)) {
if (!Serializable::getVariable<String>(String("SceneObject.zone").hashCode(),
&zoneReference, objectData)) {
objectData->clear();
continue;
}
if (zoneName != zoneReference) {
objectData->clear();
continue;
}
Reference<SceneObject*> object = server->getObject(objectID);
if (object != NULL) {
++i;
if(object->isGCWBase()){
Zone* zone = object->getZone();
if(zone == NULL)
return;
GCWManager* gcwMan = zone->getGCWManager();
if(gcwMan == NULL)
return;
gcwMan->registerGCWBase(cast<BuildingObject*>(object.get()),false);
}
if (ConfigManager::instance()->isProgressMonitorActivated())
printf("\r\tLoading player structures [%d] / [?]\t", i);
} else {
error(
"Failed to deserialize structure with objectID: "
+ String::valueOf(objectID));
}
objectData->clear();
}
delete objectData;
} catch (DatabaseException& e) {
error(
"Database exception in StructureManager::loadPlayerStructures(): "
+ e.getMessage());
}
info(String::valueOf(i) + " player structures loaded for " + zoneName + ".",
true);
}
int StructureManager::placeStructureFromDeed(CreatureObject* creature,
StructureDeed* deed, float x, float y, int angle) {
ManagedReference<Zone*> zone = creature->getZone();
//Already placing a structure?
if (zone == NULL
|| creature->containsActiveSession(
SessionFacadeType::PLACESTRUCTURE))
return 1;
ManagedReference<PlanetManager*> planetManager = zone->getPlanetManager();
String serverTemplatePath = deed->getGeneratedObjectTemplate();
if (deed->getFaction() != 0 && creature->getFaction() != deed->getFaction()) {
creature->sendSystemMessage("You are not the correct faction");
return 1;
}
Reference<SharedStructureObjectTemplate*> serverTemplate =
dynamic_cast<SharedStructureObjectTemplate*>(templateManager->getTemplate(
serverTemplatePath.hashCode()));
//Check to see if this zone allows this structure.
if (serverTemplate == NULL
|| !serverTemplate->isAllowedZone(zone->getZoneName())) {
creature->sendSystemMessage("@player_structure:wrong_planet"); //That deed cannot be used on this planet.
return 1;
}
if (!planetManager->isBuildingPermittedAt(x, y, creature)) {
creature->sendSystemMessage("@player_structure:not_permitted"); //Building is not permitted here.
return 1;
}
SortedVector<ManagedReference<ActiveArea*> > objects;
zone->getInRangeActiveAreas(x, y, &objects, true);
ManagedReference<CityRegion*> city;
for (int i = 0; i < objects.size(); ++i) {
ActiveArea* area = objects.get(i).get();
if (!area->isRegion())
continue;
city = dynamic_cast<Region*>(area)->getCityRegion();
if (city != NULL)
break;
}
SortedVector<ManagedReference<QuadTreeEntry*> > inRangeObjects;
zone->getInRangeObjects(x, y, 128, &inRangeObjects, true);
float placingFootprintLength0, placingFootprintWidth0, placingFootprintLength1, placingFootprintWidth1;
if (!getStructureFootprint(serverTemplate, angle, placingFootprintLength0, placingFootprintWidth0, placingFootprintLength1, placingFootprintWidth1)) {
float x0 = x + placingFootprintWidth0;
float y0 = y + placingFootprintLength0;
float x1 = x + placingFootprintWidth1;
float y1 = y + placingFootprintLength1;
BoundaryRectangle placingFootprint(x0, y0, x1, y1);
//info("placing center x:" + String::valueOf(x) + " y:" + String::valueOf(y), true);
//info("placingFootprint x0:" + String::valueOf(x0) + " y0:" + String::valueOf(y0) + " x1:" + String::valueOf(x1) + " y1:" + String::valueOf(y1), true);
for (int i = 0; i < inRangeObjects.size(); ++i) {
SceneObject* scene = inRangeObjects.get(i).castTo<SceneObject*>();
if (scene == NULL)
continue;
float l0 = -5; //Along the x axis.
float w0 = -5; //Along the y axis.
float l1 = 5;
float w1 = 5;
if (getStructureFootprint(scene->getObjectTemplate(), scene->getDirectionAngle(), l0, w0, l1, w1))
continue;
float xx0 = scene->getPositionX() + (w0 + 0.1);
float yy0 = scene->getPositionY() + (l0 + 0.1);
float xx1 = scene->getPositionX() + (w1 - 0.1);
float yy1 = scene->getPositionY() + (l1 - 0.1);
BoundaryRectangle rect(xx0, yy0, xx1, yy1);
//info("existing footprint xx0:" + String::valueOf(xx0) + " yy0:" + String::valueOf(yy0) + " xx1:" + String::valueOf(xx1) + " yy1:" + String::valueOf(yy1), true);
// check 4 points of the current rect
if (rect.containsPoint(x0, y0)
|| rect.containsPoint(x0, y1)
|| rect.containsPoint(x1, y0)
|| rect.containsPoint(x1, y1) ) {
//info("existing footprint contains placing point", true);
creature->sendSystemMessage("@player_structure:no_room"); //there is no room to place the structure here..
return 1;
}
if (placingFootprint.containsPoint(xx0, yy0)
|| placingFootprint.containsPoint(xx0, yy1)
|| placingFootprint.containsPoint(xx1, yy0)
|| placingFootprint.containsPoint(xx1, yy1)
|| (xx0 == x0 && yy0 == y0 && xx1 == x1 && yy1 == y1)) {
//info("placing footprint contains existing point", true);
creature->sendSystemMessage("@player_structure:no_room"); //there is no room to place the structure here.
return 1;
}
}
}
int rankRequired = serverTemplate->getCityRankRequired();
if (city == NULL && rankRequired > 0) {
creature->sendSystemMessage("@city/city:build_no_city");
return 1;
}
if (city != NULL) {
if (city->isZoningEnabled()
&& !city->hasZoningRights(creature->getObjectID())) {
creature->sendSystemMessage("@player_structure:no_rights"); //You don't have the right to place that structure in this city. The mayor or one of the city milita must grant you zoning rights first.
return 1;
}
if (rankRequired != 0 && city->getCityRank() < rankRequired) {
StringIdChatParameter param("city/city", "rank_req");
param.setDI(rankRequired);
param.setTO("city/city", "rank" + String::valueOf(rankRequired));
creature->sendSystemMessage(param);
return 1;
}
if (serverTemplate->isCivicStructure() && !city->isMayor(creature->getObjectID()) ) {
creature->sendSystemMessage("@player_structure:cant_place_civic");//"This structure must be placed within the borders of the city in which you are mayor."
return 1;
}
if (serverTemplate->isUniqueStructure()
&& city->hasUniqueStructure(
serverTemplate->getServerObjectCRC())) {
creature->sendSystemMessage("@player_structure:cant_place_unique"); //This city can only support a single structure of this type.
return 1;
}
}
Locker _lock(deed, creature);
if(serverTemplate->isDerivedFrom("object/building/faction_perk/base/shared_factional_building_base.iff")){
Zone* zone = creature->getZone();
if(zone == NULL)
return 1;
GCWManager* gcwMan = zone->getGCWManager();
if(gcwMan == NULL)
return 1;
if(!gcwMan->canPlaceMoreBases(creature))
return 1;
}
//Ensure that it is the correct deed, and that it is in a container in the creature's inventory.
if (deed == NULL || !deed->isASubChildOf(creature)) {
creature->sendSystemMessage("@player_structure:no_possession"); //You no longer are in possession of the deed for this structure. Aborting construction.
return 1;
}
TemplateManager* templateManager = TemplateManager::instance();
ManagedReference<PlayerObject*> ghost = creature->getPlayerObject();
if (ghost != NULL) {
String abilityRequired = serverTemplate->getAbilityRequired();
if (!abilityRequired.isEmpty() && !ghost->hasAbility(abilityRequired)) {
creature->sendSystemMessage("@player_structure:" + abilityRequired);
return 1;
}
int lots = serverTemplate->getLotSize();
if (!ghost->hasLotsRemaining(lots)) {
StringIdChatParameter param("@player_structure:not_enough_lots");
param.setDI(lots);
creature->sendSystemMessage(param);
return 1;
}
}
//Validate that the structure can be placed at the given coordinates:
//Ensure that no other objects impede on this structures footprint, or overlap any city regions or no build areas.
//Make sure that the player has zoning rights in the area.
ManagedReference<PlaceStructureSession*> session =
new PlaceStructureSession(creature, deed);
creature->addActiveSession(SessionFacadeType::PLACESTRUCTURE, session);
//Construct the structure.
session->constructStructure(x, y, angle);
//Remove the deed from it's container.
deed->destroyObjectFromWorld(true);
return 0;
}
void StructureManager::reportStructureStatus(CreatureObject* creature,
StructureObject* structure) {
ManagedReference<PlayerObject*> ghost = creature->getPlayerObject();
if (ghost == NULL)
return;
//Close the window if it is already open.
ghost->closeSuiWindowType(SuiWindowType::STRUCTURE_STATUS);
ManagedReference<SuiListBox*> status = new SuiListBox(creature,
SuiWindowType::STRUCTURE_STATUS);
status->setPromptTitle("@player_structure:structure_status_t"); //Structure Status
status->setPromptText(
"@player_structure:structure_name_prompt "
+ structure->getDisplayedName()); //Structure Name:
status->setUsingObject(structure);
status->setOkButton(true, "@refresh");
status->setCancelButton(true, "@cancel");
status->setCallback(new StructureStatusSuiCallback(server));
ManagedReference<SceneObject*> ownerObject = server->getObject(
structure->getOwnerObjectID());
if (ownerObject != NULL && ownerObject->isCreatureObject()) {
CreatureObject* owner = cast<CreatureObject*>(ownerObject.get());
status->addMenuItem(
"@player_structure:owner_prompt " + owner->getFirstName());
}
uint64 declaredOidResidence = ghost->getDeclaredResidence();
ManagedReference<BuildingObject*> declaredResidence =
server->getObject(declaredOidResidence).castTo<BuildingObject*>();
if (declaredResidence == structure) {
status->addMenuItem("@player_structure:declared_residency"); //You have declared your residency here.
}
if (structure->isPrivateStructure() && !structure->isCivicStructure()) {
status->addMenuItem("@player_structure:structure_private"); //This structure is private
} else {
status->addMenuItem("@player_structure:structure_public"); //This structure is public
}
status->addMenuItem(
"@player_structure:condition_prompt "
+ String::valueOf(structure->getDecayPercentage()) + "%");
if (!structure->isCivicStructure() && !structure->isGCWBase()) {
// property tax
float propertytax = 0.f;
if(!structure->isCivicStructure() && structure->getCityRegion() != NULL){
ManagedReference<CityRegion*> city = structure->getCityRegion().get();
if(city != NULL){
propertytax = city->getPropertyTax()/ 100.f * structure->getMaintenanceRate();
status->addMenuItem(
"@city/city:property_tax_prompt : "
+ String::valueOf(ceil(propertytax))
+ " cr/hr");
}
}
// maintenance
float secsRemainingMaint = 0.f;
if( structure->getSurplusMaintenance() > 0 ){
float totalrate = (float)structure->getMaintenanceRate() + propertytax;
secsRemainingMaint = ((float)structure->getSurplusMaintenance() / totalrate)*3600;
}
status->addMenuItem(
"@player_structure:maintenance_pool_prompt "
+ String::valueOf( (int) floor( (float) structure->getSurplusMaintenance()))
+ " "
+ getTimeString( (uint32)secsRemainingMaint ) );
status->addMenuItem(
"@player_structure:maintenance_rate_prompt "
+ String::valueOf(structure->getMaintenanceRate())
+ " cr/hr");
status->addMenuItem(
"@player_structure:maintenance_mods_prompt "
+ structure->getMaintenanceMods());
}
if (structure->isInstallationObject() && !structure->isGeneratorObject() && !structure->isCivicStructure()) {
InstallationObject* installation = cast<InstallationObject*>(structure);
float secsRemainingPower = 0.f;
float basePowerRate = installation->getBasePowerRate();
if((installation->getSurplusPower() > 0) && (basePowerRate != 0)){
secsRemainingPower = ((float)installation->getSurplusPower() / (float)basePowerRate)*3600;
}
status->addMenuItem(
"@player_structure:power_reserve_prompt "
+ String::valueOf( (int) installation->getSurplusPower())
+ " "
+ getTimeString( (uint32)secsRemainingPower ) );
status->addMenuItem(
"@player_structure:power_consumption_prompt "
+ String::valueOf(
(int) installation->getBasePowerRate())
+ " @player_structure:units_per_hour");
}
if (structure->isBuildingObject()) {
BuildingObject* building = cast<BuildingObject*>(structure);
if (building->isGCWBase()) {
Zone* zone = creature->getZone();
if (zone != NULL) {
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan != NULL)
status->addMenuItem(gcwMan->getVulnerableStatus(building, creature));
}
}
status->addMenuItem(
"@player_structure:items_in_building_prompt "
+ String::valueOf(
building->getCurrentNumberOfPlayerItems())); //Number of Items in Building:
}
ghost->addSuiBox(status);
creature->sendMessage(status->generateMessage());
}
