void StructureSetAccessFeeSessionImplementation::promptSetAccessFee() {
if(!structure->isOnAdminList(player)) {
cancelSession();
return;
}
if(structure->isPrivateStructure()) {
player->sendSystemMessage("@player_structure:public_only");
cancelSession();
return;
}
if(feeAmountBox == NULL) {
feeAmountBox = new SuiInputBox(player, SuiWindowType::STRUCTURE_SET_ACCESS_FEE);
feeAmountBox->setCallback(new StructureSetAccessFeeSuiCallback(player->getZoneServer()));
feeAmountBox->setPromptTitle("@player_structure:access_fee_t"); //Access Fee
feeAmountBox->setUsingObject(structure);
feeAmountBox->setMaxInputSize(4);
feeAmountBox->setPromptText("@player_structure:access_fee"); // How much would you like to charge people to enter the building
}
playerGhost->addSuiBox(feeAmountBox);
player->sendMessage(feeAmountBox->generateMessage());
}
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;
}
int PlaceStructureSessionImplementation::completeSession() {
if (constructionBarricade != NULL)
constructionBarricade->destroyObjectFromWorld(true);
String serverTemplatePath = deedObject->getGeneratedObjectTemplate();
StructureManager* structureManager = StructureManager::instance();
ManagedReference<StructureObject*> structureObject = structureManager->placeStructure(creatureObject, serverTemplatePath, positionX, positionY, directionAngle);
removeTemporaryNoBuildZone();
if (structureObject == NULL) {
ManagedReference<SceneObject*> inventory = creatureObject->getSlottedObject("inventory");
if (inventory != NULL)
inventory->transferObject(deedObject, -1, true);
return cancelSession();
}
structureObject->setDeedObjectID(deedObject->getObjectID());
deedObject->notifyStructurePlaced(creatureObject, structureObject);
ManagedReference<PlayerObject*> ghost = creatureObject->getPlayerObject();
if (ghost != NULL) {
ghost->addOwnedStructure(structureObject);
//Create Waypoint
ManagedReference<WaypointObject*> waypointObject = ( zone->getZoneServer()->createObject(String("object/waypoint/world_waypoint_blue.iff").hashCode(), 1)).castTo<WaypointObject*>();
waypointObject->setCustomObjectName(structureObject->getDisplayedName(), false);
waypointObject->setActive(true);
waypointObject->setPosition(positionX, 0, positionY);
waypointObject->setPlanetCRC(zone->getZoneCRC());
ghost->addWaypoint(waypointObject, false, true);
//Create an email.
ManagedReference<ChatManager*> chatManager = zone->getZoneServer()->getChatManager();
if (chatManager != NULL) {
UnicodeString subject = "@player_structure:construction_complete_subject";
StringIdChatParameter emailBody("@player_structure:construction_complete");
emailBody.setTO(structureObject->getObjectName());
emailBody.setDI(ghost->getLotsRemaining());
chatManager->sendMail("@player_structure:construction_complete_sender", subject, emailBody, creatureObject->getFirstName(), waypointObject);
}
if (structureObject->isBuildingObject() && !structureObject->isGCWBase()) {
BuildingObject* building = cast<BuildingObject*>(structureObject.get());
building->setCustomObjectName(creatureObject->getFirstName() + "'s House", true); //Set the house sign.
}
}
return cancelSession(); //Canceling the session just removes the session from the player's map.
}
int PlayerManagementSessionImplementation::initializeSession() {
ManagedReference<CreatureObject*> admin = this->admin.get();
if (admin == NULL)
return cancelSession();
playerManager = admin->getZoneServer()->getPlayerManager();
if (targetAccount == NULL)
return cancelSession();
return 0;
}
void ImageDesignSessionImplementation::cancelImageDesign(uint64 designer, uint64 targetPlayer, uint64 tent, int type, const ImageDesignData& data) {
ManagedReference<CreatureObject*> designerCreature = this->designerCreature.get();
ManagedReference<CreatureObject*> targetCreature = this->targetCreature.get();
if (targetCreature == NULL || designerCreature == NULL)
return;
Locker locker(designerCreature);
Locker clocker(targetCreature, designerCreature);
imageDesignData = data;
ImageDesignRejectMessage* message = new ImageDesignRejectMessage(targetCreature->getObjectID(), designer, targetPlayer,tent, type);
imageDesignData.insertToMessage(message);
targetCreature->sendMessage(message);
ImageDesignRejectMessage* msg2 = new ImageDesignRejectMessage(designerCreature->getObjectID(), designer, targetPlayer,tent, type);
imageDesignData.insertToMessage(msg2);
designerCreature->sendMessage(msg2);
//TODO: Needs research.
cancelSession();
}
void SlicingSessionImplementation::endSlicing() {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (player == NULL || tangibleObject == NULL) {
cancelSession();
return;
}
if (tangibleObject->isMissionTerminal())
player->addCooldown("slicing.terminal", (2 * (60 * 1000))); // 2min Cooldown
cancelSession();
}
void DroidMaintenanceSessionImplementation::sendMaintenanceTransferBox(){
// add result
if (selectedStructure == NULL) {
cancelSession();
return;
}
ManagedReference<CreatureObject*> creature = this->player.get();
ManagedReference<DroidMaintenanceModuleDataComponent*> module = this->maintModule.get();
// create transfer box
ManagedReference<SuiTransferBox*> sui = new SuiTransferBox(creature,SuiWindowType::DROID_ADD_STRUCTURE_AMOUNT);
sui->setCallback(new DroidMaintenanceSessionAddCreditsSuiCallback(creature->getZoneServer()));
sui->setPromptTitle("@pet/droid_modules:droid_maint_amount_title"); //Select Amount
bool offplanet = false;
if (selectedStructure->getZone()->getZoneName() != creature->getZone()->getZoneName())
offplanet = true;
StringBuffer promptText = "@pet/droid_modules:droid_maint_amount_prompt \n@player_structure:current_maint_pool "+ String::valueOf(selectedStructure->getSurplusMaintenance())+"cr";
selectedFees = 0;
if (offplanet) {
PlanetManager* planetManager = creature->getZone()->getPlanetManager();
if (planetManager == NULL) {
return;
}
int fee = planetManager->getTravelFare(selectedStructure->getZone()->getZoneName(),creature->getZone()->getZoneName());
selectedFees = fee;
promptText << "\n@pet/droid_modules:droid_maint_diff_planet_prefix " << fee << " @pet/droid_modules:droid_maint_diff_planet_suffix \n";
}
sui->setPromptText(promptText.toString());
// check for off planet, it has a fee
sui->addFrom("@player_structure:total_funds",String::valueOf(availableCredits),String::valueOf(availableCredits), "1");
sui->addTo("@player_structure:to_pay", "0", "0", "1");
creature->getPlayerObject()->addSuiBox(sui);
creature->sendMessage(sui->generateMessage());
}
bool CraftingSessionImplementation::createPrototypeObject(DraftSchematic* draftschematic) {
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
// Remove all items, incase there are any
while (craftingTool->getContainerObjectsSize() > 0) {
craftingTool->getContainerObject(0)->destroyObjectFromWorld(true);
}
prototype = (crafter.get()->getZoneServer()->createObject(
draftschematic->getTanoCRC(), 0)).castTo<TangibleObject*>();
if (prototype == NULL) {
crafter.get()->sendSystemMessage("@ui_craft:err_no_prototype");
closeCraftingWindow(1);
cancelSession();
return false;
}
prototype.get()->createChildObjects();
craftingTool->transferObject(prototype.get(), -1, false);
prototype.get()->sendTo(crafter.get(), true);
if(crafterGhost != NULL && crafterGhost.get()->getDebug()) {
crafter.get()->sendSystemMessage("Prototype Created");
}
return true;
}
int ImageDesignSessionImplementation::doPayment() {
ManagedReference<CreatureObject*> designerCreature = this->designerCreature.get();
ManagedReference<CreatureObject*> targetCreature = this->targetCreature.get();
int targetCredits = targetCreature->getCashCredits() + targetCreature->getBankCredits();
uint32 requiredPayment = imageDesignData.getRequiredPayment();
// The client should prevent this, but in case it doesn't
if (targetCredits < requiredPayment) {
targetCreature->sendSystemMessage("You do not have enough credits to pay the required payment.");
designerCreature->sendSystemMessage("Target does not have enough credits for the required payment.");
cancelSession();
return 0;
}
if (requiredPayment <= targetCreature->getCashCredits()) {
targetCreature->subtractCashCredits(requiredPayment);
designerCreature->addCashCredits(requiredPayment);
} else {
int requiredBankCredits = requiredPayment - targetCreature->getCashCredits();
targetCreature->subtractCashCredits(targetCreature->getCashCredits());
targetCreature->subtractBankCredits(requiredBankCredits);
designerCreature->addCashCredits(requiredPayment);
}
return 1;
}
void StructureSetAccessFeeSessionImplementation::setAccessDuration(const int duration) {
structure->setAccessFee(accessFee, duration);
player->sendSystemMessage("Structure now has an access fee");
cancelSession();
}
void CraftingSessionImplementation::createManufactureSchematic(int clientCounter) {
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<PlayerObject*> crafterGhost = this->crafterGhost.get();
ManagedReference<CraftingStation*> craftingStation = this->craftingStation.get();
ManagedReference<ManufactureSchematic*> manufactureSchematic = this->manufactureSchematic.get();
ManagedReference<TangibleObject*> prototype = this->prototype.get();
ManagedReference<CraftingManager*> craftingManager = this->craftingManager.get();
if (manufactureSchematic == NULL) {
sendSlotMessage(0, IngredientSlot::NOSCHEMATIC);
return;
}
if (prototype == NULL) {
sendSlotMessage(0, IngredientSlot::PROTOTYPENOTFOUND);
return;
}
if (!craftingManager.get()->allowManufactureSchematic(manufactureSchematic)){
sendSlotMessage(0, IngredientSlot::NOSCHEMATIC);
return;
}
Locker locker(_this.get());
if (manufactureSchematic->isAssembled()
&& !manufactureSchematic->isCompleted()) {
//Object Controller
ObjectControllerMessage* objMsg = new ObjectControllerMessage(
crafter->getObjectID(), 0x1B, 0x010C);
objMsg->insertInt(0x10B);
objMsg->insertInt(1);
objMsg->insertByte(clientCounter);
crafter->sendMessage(objMsg);
ManagedReference<SceneObject*> datapad = crafter->getSlottedObject("datapad");
prototype->destroyObjectFromWorld(0);
manufactureSchematic->setPersistent(2);
prototype->setPersistent(2);
datapad->transferObject(manufactureSchematic, -1, true);
manufactureSchematic->setPrototype(prototype);
} else {
closeCraftingWindow(clientCounter);
sendSlotMessage(clientCounter, IngredientSlot::WEIRDFAILEDMESSAGE);
}
cancelSession();
}
void SlicingSessionImplementation::handleMenuSelect(CreatureObject* pl, byte menuID, SuiListBox* suiBox) {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (tangibleObject == NULL || player == NULL || player != pl)
return;
uint8 progress = getProgress();
if (progress == 0) {
switch(menuID) {
case 0: {
if (hasPrecisionLaserKnife()) {
if (firstCable != 0)
handleSliceFailed(); // Handle failed slice attempt
else
cableBlue = true;
} else
player->sendSystemMessage("@slicing/slicing:no_knife");
break;
}
case 1: {
if (hasPrecisionLaserKnife()) {
if (firstCable != 1)
handleSliceFailed(); // Handle failed slice attempt
else
cableRed = true;
} else
player->sendSystemMessage("@slicing/slicing:no_knife");
break;
}
case 2:
handleUseClamp(); // Handle Use of Molecular Clamp
break;
case 3: {
handleUseFlowAnalyzer(); // Handle Use of Flow Analyzer
break;
}
default:
cancelSession();
break;
}
} else {
if (hasPrecisionLaserKnife()) {
if (firstCable != menuID)
handleSlice(suiBox); // Handle Successful Slice
else
handleSliceFailed(); // Handle failed slice attempt //bugfix 820
return;
} else
player->sendSystemMessage("@slicing/slicing:no_knife");
}
generateSliceMenu(suiBox);
}
int StructureSetAccessFeeSessionImplementation::initializeSession() {
if(player == NULL || structure == NULL) {
cancelSession();
return 0;
}
if(!structure->isOnAdminList(player)) {
cancelSession();
return 0;
}
if(structure->isPrivateStructure()) {
player->sendSystemMessage("@player_structure:public_only");
cancelSession();
return 0;
}
return 1;
}
void DroidMaintenanceSessionImplementation::addCreditsToCurrentStructure(int amount) {
// WE know the current structure add it to our pay list.
if (selectedStructure == NULL) {
cancelSession();
return;
}
this->maintenance.put(selectedStructure->getObjectID(),amount);
if (selectedFees > 0){
fees.add(selectedFees);
}
}
void CraftingSessionImplementation::createPrototype(int clientCounter, bool createItem) {
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<ManufactureSchematic*> manufactureSchematic = this->manufactureSchematic.get();
if (manufactureSchematic == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::NOSCHEMATIC);
return;
}
if (prototype == NULL) {
sendSlotMessage(clientCounter, IngredientSlot::PROTOTYPENOTFOUND);
return;
}
Locker locker(_this.get());
Locker locker2(manufactureSchematic);
if (manufactureSchematic->isAssembled()
&& !manufactureSchematic->isCompleted()) {
closeCraftingWindow(clientCounter);
String xpType = manufactureSchematic->getDraftSchematic()->getXpType();
int xp = manufactureSchematic->getDraftSchematic()->getXpAmount();
if (createItem) {
startCreationTasks(manufactureSchematic->getComplexity() * 2, false);
} else {
// This is for practicing
startCreationTasks(manufactureSchematic->getComplexity() * 2, true);
xp *= 1.05f;
}
Reference<PlayerManager*> playerManager = crafter->getZoneServer()->getPlayerManager();
playerManager->awardExperience(crafter, xpType, xp, true);
manufactureSchematic->setCompleted();
} else {
closeCraftingWindow(clientCounter);
sendSlotMessage(clientCounter, IngredientSlot::WEIRDFAILEDMESSAGE);
}
cancelSession();
}
void EntertainingSessionImplementation::doPerformanceAction() {
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
if (entertainer == NULL)
return;
Locker locker(entertainer);
Performance* performance = NULL;
PerformanceManager* performanceManager = SkillManager::instance()->getPerformanceManager();
ManagedReference<Instrument*> instrument = getInstrument(entertainer);
if (isDancing())
performance = performanceManager->getDance(performanceName);
else if (isPlayingMusic() && instrument)
performance = performanceManager->getSong(performanceName, instrument->getInstrumentType());
else {
cancelSession();
return;
}
if (performance == NULL) { // shouldn't happen
StringBuffer msg;
msg << "Performance was null. Please report to www.swgemu.com/bugs ! Name: " << performanceName << " and Type: " << dec << instrument->getInstrumentType();
entertainer->sendSystemMessage(msg.toString());
return;
}
int actionDrain = performance->getActionPointsPerLoop();
//Adjust cost based upon player's quickness
actionDrain = entertainer->calculateCostAdjustment(CreatureAttribute::QUICKNESS, actionDrain);
if (entertainer->getHAM(CreatureAttribute::ACTION) <= actionDrain) {
if (isDancing()) {
stopDancing();
entertainer->sendSystemMessage("@performance:dance_too_tired");
}
if (isPlayingMusic()) {
stopPlayingMusic();
entertainer->sendSystemMessage("@performance:music_too_tired");
}
} else {
entertainer->inflictDamage(entertainer, CreatureAttribute::ACTION, actionDrain, false, true);
}
}
int DestroyStructureSessionImplementation::initializeSession() {
//TODO: Temporary until CreatureObject* dependency removed.
if (!creatureObject->isPlayerCreature())
return cancelSession();
creatureObject->addActiveSession(SessionFacadeType::DESTROYSTRUCTURE, _this.getReferenceUnsafeStaticCast());
Locker _lock(structureObject, creatureObject);
CreatureObject* player = cast<CreatureObject*>( creatureObject.get());
String no = "\\#FF6347 @player_structure:can_redeed_no_suffix \\#.";
String yes = "\\#32CD32 @player_structure:can_redeed_yes_suffix \\#.";
String redeed = (structureObject->isRedeedable()) ? yes : no;
StringBuffer maint;
maint << "@player_structure:redeed_maintenance \\#" << ((structureObject->isRedeedable()) ? "32CD32 " : "FF6347 ") << structureObject->getSurplusMaintenance() << "/" << structureObject->getRedeedCost() << "\\#.";
StringBuffer entry;
entry << "@player_structure:confirm_destruction_d1 ";
entry << "@player_structure:confirm_destruction_d2 \n\n";
entry << "@player_structure:confirm_destruction_d3a ";
entry << "\\#32CD32 @player_structure:confirm_destruction_d3b \\#. ";
entry << "@player_structure:confirm_destruction_d4 \n";
entry << "@player_structure:redeed_confirmation " << redeed;
StringBuffer cond;
cond << "@player_structure:redeed_condition \\#32CD32 " << (structureObject->getMaxCondition() - structureObject->getConditionDamage()) << "/" << structureObject->getMaxCondition() << "\\#.";
ManagedReference<SuiListBox*> sui = new SuiListBox(player);
sui->setCallback(new DestroyStructureRequestSuiCallback(creatureObject->getZoneServer()));
sui->setCancelButton(true, "@no");
sui->setOkButton(true, "@yes");
sui->setUsingObject(structureObject);
sui->setPromptTitle(structureObject->getDisplayedName());
sui->setPromptText(entry.toString());
sui->addMenuItem("@player_structure:can_redeed_alert " + redeed);
sui->addMenuItem(cond.toString());
sui->addMenuItem(maint.toString());
player->getPlayerObject()->addSuiBox(sui);
player->sendMessage(sui->generateMessage());
return 0;
}
void EntertainingSessionImplementation::increaseEntertainerBuff(CreatureObject* patron){
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
PerformanceManager* performanceManager = SkillManager::instance()->getPerformanceManager();
Performance* performance = NULL;
ManagedReference<Instrument*> instrument = getInstrument(entertainer);
if (performanceName == "")
return;
if (dancing) {
performance = performanceManager->getDance(performanceName);
} else if (playingMusic && instrument != NULL) {
performance = performanceManager->getSong(performanceName, instrument->getInstrumentType());
} else {
cancelSession();
return;
}
if(!canGiveEntertainBuff())
return;
if (performance == NULL) { // shouldn't happen
return;
}
ManagedReference<PlayerObject*> entPlayer = entertainer->getPlayerObject();
//Check if the patron is a valid buff target
//Whether it be passive(in the same group) or active (/setPerform target)
if ((!entertainer->isGrouped() || entertainer->getGroupID() != patron->getGroupID())
&& entPlayer->getPerformanceBuffTarget() != patron->getObjectID()) {
return;
}
if(isInDenyServiceList(patron))
return;
float buffAcceleration = 1 + ((float)entertainer->getSkillMod("accelerate_entertainer_buff") / 100.f);
addEntertainerBuffDuration(patron, performance->getType(), 2.0f * buffAcceleration);
addEntertainerBuffStrength(patron, performance->getType(), performance->getHealShockWound());
}
int PlaceStructureSessionImplementation::constructStructure(float x, float y, int angle) {
positionX = x;
positionY = y;
directionAngle = angle;
TemplateManager* templateManager = TemplateManager::instance();
String serverTemplatePath = deedObject->getGeneratedObjectTemplate();
Reference<SharedStructureObjectTemplate*> serverTemplate = dynamic_cast<SharedStructureObjectTemplate*>(templateManager->getTemplate(serverTemplatePath.hashCode()));
if (serverTemplate == NULL || temporaryNoBuildZone != NULL)
return cancelSession(); //Something happened, the server template is not a structure template or temporaryNoBuildZone already set.
placeTemporaryNoBuildZone(serverTemplate);
String barricadeServerTemplatePath = serverTemplate->getConstructionMarkerTemplate();
int constructionDuration = 100; //Set the duration for 100ms as a fall back if it doesn't have a barricade template.
if (!barricadeServerTemplatePath.isEmpty()) {
constructionBarricade = ObjectManager::instance()->createObject(barricadeServerTemplatePath.hashCode(), 0, "");
if (constructionBarricade != NULL) {
constructionBarricade->initializePosition(x, 0, y); //The construction barricades are always at the terrain height.
StructureFootprint* structureFootprint = serverTemplate->getStructureFootprint();
if (structureFootprint != NULL && (structureFootprint->getRowSize() > structureFootprint->getColSize())) {
angle = angle + 180;
}
constructionBarricade->rotate(angle); //All construction barricades need to be rotated 180 degrees for some reason.
//constructionBarricade->insertToZone(zone);
zone->transferObject(constructionBarricade, -1, true);
constructionDuration = serverTemplate->getLotSize() * 3000; //3 seconds per lot.
}
}
Reference<Task*> task = new StructureConstructionCompleteTask(creatureObject);
task->schedule(constructionDuration);
return 0;
}
bool CraftingSessionImplementation::createManufactureSchematic(DraftSchematic* draftschematic) {
manufactureSchematic =
(draftschematic->createManufactureSchematic(craftingTool.get())).castTo<ManufactureSchematic*>();
if (manufactureSchematic == NULL) {
crafter.get()->sendSystemMessage("@ui_craft:err_no_manf_schematic");
closeCraftingWindow(1);
cancelSession();
return false;
}
craftingTool.get()->transferObject(manufactureSchematic.get(), 0x4, true);
//manufactureSchematic->sendTo(crafter, true);
if(crafterGhost != NULL && crafterGhost.get()->getDebug()) {
crafter.get()->sendSystemMessage("ManufactureSchematic Created");
}
return true;
}
void WhiteboardManager::handleUIEvent(std::shared_ptr<UIEvent> event) {
std::shared_ptr<RequestWhiteboardUIEvent> requestWhiteboardEvent = std::dynamic_pointer_cast<RequestWhiteboardUIEvent>(event);
if (requestWhiteboardEvent) {
requestSession(requestWhiteboardEvent->getContact());
}
std::shared_ptr<AcceptWhiteboardSessionUIEvent> sessionAcceptEvent = std::dynamic_pointer_cast<AcceptWhiteboardSessionUIEvent>(event);
if (sessionAcceptEvent) {
acceptSession(sessionAcceptEvent->getContact());
}
std::shared_ptr<CancelWhiteboardSessionUIEvent> sessionCancelEvent = std::dynamic_pointer_cast<CancelWhiteboardSessionUIEvent>(event);
if (sessionCancelEvent) {
cancelSession(sessionCancelEvent->getContact());
}
std::shared_ptr<ShowWhiteboardUIEvent> showWindowEvent = std::dynamic_pointer_cast<ShowWhiteboardUIEvent>(event);
if (showWindowEvent) {
WhiteboardWindow* window = findWhiteboardWindow(showWindowEvent->getContact());
if (window != nullptr) {
window->activateWindow();
}
}
}
int DestroyStructureSessionImplementation::sendDestroyCode() {
//TODO: Temporary until CreatureObject* dependency removed.
if (!creatureObject->isPlayerCreature())
return cancelSession();
Locker structureLock(structureObject);
Locker _lock(creatureObject, structureObject);
CreatureObject* player = cast<CreatureObject*>( creatureObject.get());
destroyCode = System::random(899999) + 100000;
String no = "\\#FF6347 @player_structure:will_not_redeed_confirm \\#.";
String yes = "\\#32CD32 @player_structure:will_redeed_confirm \\#.";
String redeed = (structureObject->isRedeedable()) ? yes : no;
StringBuffer entry;
entry << "@player_structure:your_structure_prefix ";
entry << redeed << " @player_structure:will_redeed_suffix \n\n";
entry << "Code: " << destroyCode;
ManagedReference<SuiInputBox*> sui = new SuiInputBox(player);
sui->setCallback(new DestroyStructureCodeSuiCallback(player->getZoneServer()));
sui->setUsingObject(structureObject);
sui->setPromptTitle("@player_structure:confirm_destruction_t"); //Confirm Structure Deletion
sui->setPromptText(entry.toString());
sui->setCancelButton(true, "@cancel");
sui->setMaxInputSize(6);
player->getPlayerObject()->addSuiBox(sui);
player->sendMessage(sui->generateMessage());
return 0;
}
void DroidMaintenanceSessionImplementation::sendMaintanceRunBox(){
// main ui
selectedStructure = NULL;
ManagedReference<CreatureObject*> creature = this->player.get();
if (structures.size() == 0 && maintenance.isEmpty()) {
creature->sendSystemMessage("@pet/droid_modules:droid_maint_no_valid_struct");
cancelSession();
return;
}
ManagedReference<DroidMaintenanceModuleDataComponent*> module = this->maintModule.get();
ManagedReference<SuiListBox*> box = new SuiListBox(creature, SuiWindowType::DROID_MAINTENANCE_RUN_LIST, SuiListBox::HANDLETHREEBUTTON);
box->setCallback(new DroidMaintenanceSessionRunMenuSuiCallback(creature->getZoneServer()));
// we need to add additional text i think
StringBuffer promptText;
box->setPromptTitle("@pet/droid_modules:droid_maint_list_title"); // Maintenance Run
SuiListBox* b;
box->setOkButton(true, "@go");
box->setOtherButton(true,"@add");
box->setCancelButton(true, "@cancel");
// we have all we need in the session.
int addCount = 0;
// we need to add a line item for every structure on this droids list, then track amount per structure + fees + interplanetary. i.e. if not interplanetary capable, dont show them.
//Vector<StructureObject*> list = module->getStructureList(creature->getZoneServer(),creature->getZone()->getZoneCRC());
for(int i=0;i<structures.size();i++) {
ManagedReference<StructureObject*> obj = structures.elementAt(i);
StringBuffer buff;
String zoneName = "the void";
if (obj->getZone() != NULL) {
zoneName = obj->getZone()->getZoneName();
}
// assume 30 chars per section, 3 sections so 90 chars.
int nameLength = obj->getDisplayedName().length();
int zoneNameLength = zoneName.length();
buff << obj->getDisplayedName();
if (nameLength < 30) {
// pad the diff to teh end
for(int x=0;x<30-nameLength;x++)
buff << " ";
nameLength = 30;
}
int finalOffset = zoneName.length() + 15;
buff << "\t" << zoneName << "(" << String::valueOf((int)obj->getPositionX()) << "," << String::valueOf((int)obj->getPositionY()) << ")";
if (maintenance.contains(obj->getObjectID())) {
if (addCount == 0)
promptText << "@pet/droid_modules:droid_maint_list_header\n\n";
addCount += 1;
promptText << buff.toString();
if (finalOffset < 30) {
for(int x=0;x<30-finalOffset;x++)
promptText << " ";
}
promptText << "+" << maintenance.get(obj->getObjectID()) << "\n";
} else {
box->addMenuItem( buff.toString(), obj->getObjectID());
}
}
if (addCount > 0)
promptText << "\n";
promptText << "@pet/droid_modules:droid_maint_list_prompt"; // Please select a structure to perform a maintenance run on. Once all structures to be maintained have been selected, press the Go button.
box->setPromptText(promptText.toString());
creature->getPlayerObject()->addSuiBox(box);
creature->sendMessage(box->generateMessage());
}
void DroidMaintenanceSessionImplementation::performMaintenanceRun(){
// launch the task and set droid cooldown.
ManagedReference<CreatureObject*> creature = this->player.get();
if (maintenance.size() == 0) {
creature->sendSystemMessage("@pet/droid_modules:droid_maint_empty_maint_run");
sendMaintanceRunBox();
return;
}
// pay all structures
long totalCosts = 0;
long totalFees = 0;
for(int i=0;i<fees.size();i++)
totalFees += fees.elementAt(i);
for(int i =0; i< maintenance.size();i++)
totalCosts += maintenance.elementAt(i).getValue();
// pay fees
if (availableCredits < totalCosts + totalFees) {
if (availableCredits > totalCosts)
creature->sendSystemMessage("@pet/droid_modules:droid_maint_cant_travel");
else
creature->sendSystemMessage("@pet/droid_modules:droid_maint_not_enough_cash");
cancelSession();
return;
}
// he had enough credits, so lets perform the run .
ManagedReference<DroidMaintenanceModuleDataComponent*> module = this->maintModule.get();
ManagedReference<DroidObject*> droid = module->getDroidObject();
long time = module->calculateRunTime(maintenance);
long powerCost = time/1000/60/15;
// check for power now as it may hit zero while we are in the menu
if (!droid->hasPower()) {
creature->sendSystemMessage("@pet/droid_modules:not_enough_power"); // Your droid dosnt have enough power to do that.
cancelSession();
return;
}
// we might get killed off due to no power, do we let it run anyways and jsut leave droid as drained for later.
// that seems ok he wont be able to touch the droid for a long time anyways so lets roleplay out it just runs out in low power situation.
// we had enough to run.
if (creature->getCashCredits() >= totalFees) {
creature->subtractCashCredits(totalFees);
} else {
int payedSoFar = creature->getCashCredits();
creature->subtractCashCredits(payedSoFar);
creature->subtractBankCredits(totalFees - payedSoFar);
}
// now the structures.
Locker clock(creature);
module->payStructures(creature,maintenance);
// calculate time
// we got milliseconds convert to minutes
long minutes = time/1000; // seconds
const static String abbrvs[3] = { "seconds", "minutes, ", "hours" };
const static int intervals[3] = { 1, 60, 3600 };
int values[3] = { 0, 0, 0 };
StringBuffer str;
str << "Maintenance run started. Completion ETA: ";
for (int i = 2; i > -1; --i) {
values[i] = floor((float) minutes / intervals[i]);
minutes -= values[i] * intervals[i];
if (values[i] > 0) {
if (str.length() > 0){
str << " ";
}
str << values[i] << " " << abbrvs[i];
}
}
creature->sendSystemMessage(str.toString());
Locker droidLock(droid, creature);
// store the pet off and set the call cooldown.
droid->getCooldownTimerMap()->updateToCurrentAndAddMili("call_cooldown",time);
Reference<StorePetTask*> task = new StorePetTask(this->player.get(), droid);
droid->usePower(DroidObject::MAX_POWER); // According to what i read, doing the run drains all power from teh droid.
task->execute();
}
int CraftingSessionImplementation::startSession() {
// crafter and craftingTool locked already in initializeSession
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<PlayerObject*> crafterGhost = this->crafterGhost.get();
ManagedReference<CraftingStation*> craftingStation = this->craftingStation.get();
if(crafter == NULL || craftingTool == NULL || crafterGhost == NULL) {
cancelSession();
return false;
}
/// Get current allowed complexity
ManagedReference<PlayerObject*> playerObject = crafter->getPlayerObject();
int complexityLevel = craftingTool->getComplexityLevel();
if (craftingStation != NULL)
complexityLevel = craftingStation->getComplexityLevel();
/// Get filtered schematic list based on tool type and complexity
currentSchematicList.removeAll();
currentSchematicList =
playerObject->filterSchematicList(crafter,
craftingTool->getToolTabs(), complexityLevel);
/// DPlay9 ***********************************
PlayerObjectDeltaMessage9* dplay9 =
new PlayerObjectDeltaMessage9(playerObject);
dplay9->setExperimentationEnabled(craftingStation != NULL);
dplay9->setCraftingState(1);
if (craftingStation != NULL)
dplay9->setClosestCraftingStation(craftingStation->getObjectID());
else
dplay9->setClosestCraftingStation(0);
dplay9->setExperimentationPoints(experimentationPointsTotal);
dplay9->close();
crafter->sendMessage(dplay9);
// End dplay9***********************************
/// Object Controller Message 102 - Schematic List
ObjectControllerMessage* ocm = new ObjectControllerMessage(
crafter->getObjectID(), 0x0B, 0x102);
ocm->insertLong(craftingTool->getObjectID());
if (craftingStation != NULL)
ocm->insertLong(craftingStation->getObjectID());
else
ocm->insertLong(0);
ocm->insertInt(currentSchematicList.size());
for (int i = 0; i < currentSchematicList.size(); ++i) {
DraftSchematic* draftSchematic = currentSchematicList.get(i).get();
ocm->insertInt(draftSchematic->getClientObjectCRC());
ocm->insertInt(draftSchematic->getClientObjectCRC());
ocm->insertInt(draftSchematic->getToolTab()); // this number decides what tab the schematic goes in (ex: 4 = food tab in crafting window)
}
crafter->sendMessage(ocm);
/// ***********************************************
/// Reset session state
state = 1;
if(crafterGhost != NULL && crafterGhost->getDebug()) {
crafter->sendSystemMessage("*** Starting new crafting session ***");
}
return true;
}
void EntertainingSessionImplementation::doEntertainerPatronEffects() {
ManagedReference<CreatureObject*> creo = entertainer.get();
if (creo == NULL)
return;
if (performanceName == "")
return;
Locker locker(creo);
//**DECLARATIONS**
VectorMap<ManagedReference<CreatureObject*>, EntertainingData>* patrons = NULL;
SkillManager* skillManager = creo->getZoneServer()->getSkillManager();
PerformanceManager* performanceManager = skillManager->getPerformanceManager();
Performance* performance = NULL;
ManagedReference<Instrument*> instrument = getInstrument(creo);
float woundHealingSkill = 0.0f;
float playerShockHealingSkill = 0.0f;
float buildingShockHealingSkill = creo->getSkillMod("private_med_battle_fatigue");
float factionPerkSkill = creo->getSkillMod("private_faction_mind_heal");
//**LOAD PATRONS, GET THE PERFORMANCE AND ENT'S HEALING SKILL.**
if (dancing) {
patrons = &watchers;
performance = performanceManager->getDance(performanceName);
woundHealingSkill = (float) creo->getSkillMod("healing_dance_wound");
playerShockHealingSkill = (float) creo->getSkillMod("healing_dance_shock");
} else if (playingMusic && instrument != NULL) {
patrons = &listeners;
performance = performanceManager->getSong(performanceName, instrument->getInstrumentType());
woundHealingSkill = (float) creo->getSkillMod("healing_music_wound");
playerShockHealingSkill = (float) creo->getSkillMod("healing_music_shock");
} else {
cancelSession();
return;
}
if (performance == NULL) {
return;
}
ManagedReference<BuildingObject*> building = creo->getRootParent().get().castTo<BuildingObject*>();
if (building != NULL && factionPerkSkill > 0 && building->isPlayerRegisteredWithin(creo->getObjectID())) {
unsigned int buildingFaction = building->getFaction();
unsigned int healerFaction = creo->getFaction();
PlayerObject* ghost = creo->getPlayerObject();
if (ghost != NULL && healerFaction != 0 && healerFaction == buildingFaction && ghost->getFactionStatus() == FactionStatus::OVERT) {
woundHealingSkill += factionPerkSkill;
playerShockHealingSkill += factionPerkSkill;
}
}
//**DETERMINE WOUND HEAL AMOUNTS.**
int woundHeal = ceil(performance->getHealMindWound() * (woundHealingSkill / 100.0f));
int shockHeal = ceil(performance->getHealShockWound() * ((playerShockHealingSkill + buildingShockHealingSkill) / 100.0f));
//**ENTERTAINER HEALS THEIR OWN MIND.**
healWounds(creo, woundHeal*(flourishCount+1), shockHeal*(flourishCount+1));
//**APPLY EFFECTS TO PATRONS.**
if (patrons != NULL && patrons->size() > 0) {
for (int i = 0; i < patrons->size(); ++i) {
ManagedReference<CreatureObject*> patron = patrons->elementAt(i).getKey();
try {
//**VERIFY THE PATRON IS NOT ON THE DENY SERVICE LIST
if (creo->isInRange(patron, 10.0f)) {
healWounds(patron, woundHeal*(flourishCount+1), shockHeal*(flourishCount+1));
increaseEntertainerBuff(patron);
} else { //patron is not in range, force to stop listening
ManagedReference<PlayerManager*> playerManager = patron->getZoneServer()->getPlayerManager();
Locker locker(patron, entertainer.get());
if (dancing) {
if (playerManager != NULL)
playerManager->stopWatch(patron, creo->getObjectID(), true, false, false, true);
if (!patron->isListening())
sendEntertainmentUpdate(patron, 0, "", true);
} else if (playingMusic) {
if (playerManager != NULL)
playerManager->stopListen(patron, creo->getObjectID(), true, false, false, true);
if (!patron->isWatching())
sendEntertainmentUpdate(patron, 0, "", true);
}
}
} catch (Exception& e) {
error("Unreported exception caught in EntertainingSessionImplementation::doEntertainerPatronEffects()");
}
}
} //else
//System::out << "There are no patrons.\n";
info("EntertainingSessionImplementation::doEntertainerPatronEffects() end");
}
void EntertainingSessionImplementation::doFlourish(int flourishNumber) {
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
int fid = flourishNumber;
if (!dancing && !playingMusic) {
entertainer->sendSystemMessage("@performance:flourish_not_performing");
return;
}
PerformanceManager* performanceManager = SkillManager::instance()->getPerformanceManager();
Performance* performance = NULL;
ManagedReference<Instrument*> instrument = getInstrument(entertainer);
if (dancing)
performance = performanceManager->getDance(performanceName);
else if (playingMusic && instrument)
performance = performanceManager->getSong(performanceName, instrument->getInstrumentType());
else {
cancelSession();
return;
}
if (!performance) { // shouldn't happen
StringBuffer msg;
msg << "Performance was null. Please report to www.swgemu.com/bugs ! Name: " << performanceName << " and Type: " << dec << instrument->getInstrumentType();
entertainer->sendSystemMessage(msg.toString());
return;
}
float baseActionDrain = performance->getActionPointsPerLoop() - (int)(entertainer->getHAM(CreatureAttribute::QUICKNESS)/35.f);
//float baseActionDrain = -40 + (getQuickness() / 37.5);
float flourishActionDrain = baseActionDrain / 2.0;
int actionDrain = (int)round((flourishActionDrain * 10 + 0.5) / 10.0); // Round to nearest dec for actual int cost
if (entertainer->getHAM(CreatureAttribute::ACTION) <= actionDrain) {
entertainer->sendSystemMessage("@performance:flourish_too_tired");
} else {
entertainer->inflictDamage(entertainer, CreatureAttribute::ACTION, actionDrain, false, true);
if (dancing) {
StringBuffer msg;
msg << "skill_action_" << fid;
entertainer->doAnimation(msg.toString());
} else if (playingMusic) {
Flourish* flourish = new Flourish(entertainer, fid);
entertainer->broadcastMessage(flourish, true);
}
//check to see how many flourishes have occurred this tick
if(flourishCount < 5) {
// Add buff
addEntertainerFlourishBuff();
// Grant Experience
if(flourishCount < 2)
flourishXp += performance->getBaseXp() + performance->getFlourishXpMod();
flourishCount++;
}
entertainer->notifyObservers(ObserverEventType::FLOURISH, entertainer, fid);
entertainer->sendSystemMessage("@performance:flourish_perform");
}
}
void SlicingSessionImplementation::handleMenuSelect(CreatureObject* pl, byte menuID, SuiListBox* suiBox) {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (tangibleObject == NULL || player == NULL || player != pl)
return;
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
if (inventory == NULL)
return;
if(!isBaseSlice() && tangibleObject->getGameObjectType() != SceneObjectType::STATICLOOTCONTAINER && tangibleObject->getGameObjectType() != SceneObjectType::MISSIONTERMINAL){
if (!inventory->hasObjectInContainer(tangibleObject->getObjectID())) {
player->sendSystemMessage("The object must be in your inventory in order to perform the slice.");
return;
}
}
uint8 progress = getProgress();
if (progress == 0) {
switch(menuID) {
case 0: {
if (hasPrecisionLaserKnife()) {
if (firstCable != 0)
handleSliceFailed(); // Handle failed slice attempt
else
cableBlue = true;
} else
player->sendSystemMessage("@slicing/slicing:no_knife");
break;
}
case 1: {
if (hasPrecisionLaserKnife()) {
if (firstCable != 1)
handleSliceFailed(); // Handle failed slice attempt
else
cableRed = true;
} else
player->sendSystemMessage("@slicing/slicing:no_knife");
break;
}
case 2:
handleUseClamp(); // Handle Use of Molecular Clamp
break;
case 3: {
handleUseFlowAnalyzer(); // Handle Use of Flow Analyzer
break;
}
default:
cancelSession();
break;
}
} else {
if (hasPrecisionLaserKnife()) {
if (firstCable != menuID)
handleSlice(suiBox); // Handle Successful Slice
else
handleSliceFailed(); // Handle failed slice attempt //bugfix 820
return;
} else
player->sendSystemMessage("@slicing/slicing:no_knife");
}
generateSliceMenu(suiBox);
}
void CraftingSessionImplementation::selectDraftSchematic(int index) {
ManagedReference<CreatureObject*> crafter = this->crafter.get();
ManagedReference<PlayerObject*> crafterGhost = this->crafterGhost.get();
ManagedReference<CraftingTool*> craftingTool = this->craftingTool.get();
if (index >= currentSchematicList.size()) {
crafter->sendSystemMessage("Invalid Schematic Index");
closeCraftingWindow(1);
cancelSession();
return;
}
DraftSchematic* draftschematic = currentSchematicList.get(index);
if (draftschematic == NULL) {
crafter->sendSystemMessage("@ui_craft:err_no_draft_schematic");
closeCraftingWindow(1);
cancelSession();
return;
}
clearSession();
Locker slocker(_this.get());
if(crafterGhost != NULL && crafterGhost->getDebug()) {
crafter->sendSystemMessage("Selected DraftSchematic: " + draftschematic->getCustomName());
}
state = 2;
if (craftingTool != NULL) {
Locker locker(craftingTool);
if (createSessionObjects(draftschematic)) {
if (prototype == NULL) {
crafter->sendSystemMessage("@ui_craft:err_no_prototype");
closeCraftingWindow(1);
cancelSession();
return;
}
// Dplay9 ********************************************************
// Sets the Crafting state to 2, which is the Resource screen
PlayerObjectDeltaMessage9* dplay9 = new PlayerObjectDeltaMessage9(
crafter->getPlayerObject());
dplay9->setExperimentationPoints(0xFFFFFFFF);
dplay9->setCraftingState(2);
dplay9->close();
crafter->sendMessage(dplay9);
// End Dplay9 *****************************************************
} else {
crafter->sendSystemMessage("This type of object has not yet been implemented");
}
} else {
crafter->sendSystemMessage("@ui_craft:err_no_crafting_tool");
closeCraftingWindow(1);
cancelSession();
}
}
void PlayerManagementSessionImplementation::completeBan() {
ManagedReference<CreatureObject*> admin = this->admin.get();
if (admin == NULL)
return;
Reference<PlayerObject*> ghost = admin->getPlayerObject();
if (ghost == NULL)
return;
String message = "";
/// Update account to check for changes
Locker locker(targetAccount);
targetAccount->updateAccount();
if (banMode == ACCOUNT) {
/// Check for account status changes
if ((banType == BAN && targetAccount->isBanned()) ||
(banType == UNBAN && !targetAccount->isBanned())) {
admin->sendSystemMessage("This account has been changed since you started modifying it, please check changes and try again");
admin->sendMessage(accountBox->generateCloseMessage());
cancelSession();
return;
}
if (targetAccount->isBanned()) {
StringBuffer reason;
reason << targetAccount->getBanAdmin() << "=" << targetAccount->getBanReason() << "|" << ghost->getAccountID() << "=" << banReason;
message = playerManager->unbanAccount(ghost, targetAccount, reason.toString());
} else
message = playerManager->banAccount(ghost, targetAccount, banExpiration - time(0), banReason);
} else if (banMode == GALAXY) {
GalaxyBanEntry* galaxyBan = targetAccount->getGalaxyBan(galaxyID);
/// Check for galaxy ban status changes
if ((banType == BAN && galaxyBan != NULL) ||
(banType == UNBAN && galaxyBan == NULL)) {
admin->sendSystemMessage("This account has been changed since you started modifying it, please check changes and try again");
admin->sendMessage(accountBox->generateCloseMessage());
cancelSession();
return;
}
if (galaxyBan != NULL) {
StringBuffer reason;
reason << galaxyBan->getBanAdmin() << "=" << galaxyBan->getBanReason() << "|" << ghost->getAccountID() << "=" << banReason;
message = playerManager->unbanFromGalaxy(ghost, targetAccount, galaxyID, reason.toString());
} else
message = playerManager->banFromGalaxy(ghost, targetAccount, galaxyID, banExpiration - time(0), banReason);
} else if (banMode == CHARACTER){
CharacterListEntry* entry = targetAccount->getCharacterBan(galaxyID, targetName);
/// Check for player ban status changes
if ((banType == BAN && entry != NULL) ||
(banType == UNBAN && entry == NULL)) {
admin->sendSystemMessage("This account has been changed since you started modifying it, please check changes and try again");
admin->sendMessage(accountBox->generateCloseMessage());
cancelSession();
return;
}
if (entry != NULL) {
StringBuffer reason;
reason << entry->getBanAdmin() << "=" << entry->getBanReason() << "|" << ghost->getAccountID() << "=" << banReason;
message = playerManager->unbanCharacter(ghost, targetAccount, targetName, galaxyID, reason.toString());
} else
message = playerManager->banCharacter(ghost, targetAccount, targetName, galaxyID, banExpiration - time(0), banReason);
}
admin->sendSystemMessage(message);
//sendAccountInfo();
admin->sendMessage(accountBox->generateCloseMessage());
cancelSession();
}
