void DestroyMissionObjectiveImplementation::abort() { MissionObjectiveImplementation::abort(); if (hasObservers()) { ManagedReference<MissionObserver*> observer = getObserver(0); ManagedReference<CreatureObject*> player = getPlayerOwner(); ManagedReference<LairObject*> lair = lairObject; if (lair != NULL) { Locker locker(lair); lair->dropObserver(ObserverEventType::OBJECTDESTRUCTION, observer); lair->destroyObjectFromWorld(true); lair = NULL; dropObserver(observer, true); } //spawnActiveArea->destroyObjectFromDatabase(true); } ManagedReference<MissionSpawnActiveArea* > spawnActiveArea = this->spawnActiveArea; if (spawnActiveArea != NULL) { Locker locker(spawnActiveArea); spawnActiveArea->destroyObjectFromWorld(true); } }
int CraftingSessionImplementation::clearSession() { Locker slocker(_this.get()); 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(); if (manufactureSchematic != NULL) { Locker locker(manufactureSchematic); if (manufactureSchematic->getParent() == craftingTool) { manufactureSchematic->setDraftSchematic(NULL); manufactureSchematic->cleanupIngredientSlots(crafter); manufactureSchematic->destroyObjectFromWorld(true); } this->manufactureSchematic = NULL; } if (craftingTool != NULL) { Locker locker2(craftingTool); // Remove all items that aren't the prototype while (craftingTool->getContainerObjectsSize() > 1) { craftingTool->getContainerObject(1)->destroyObjectFromWorld(true); } craftingTool->dropSlottedObject("crafted_components"); if (prototype != NULL) { Locker locker3(prototype); if (craftingTool->isReady()) { if (prototype->getParent() == craftingTool) { prototype->destroyObjectFromWorld(true); } this->prototype = NULL; } } } if(crafterGhost != NULL && crafterGhost->getDebug()) { crafter->sendSystemMessage("*** Clearing crafting session ***"); } return 0; }
TangibleObject* ImageDesignManager::updateHairObject(CreatureObject* creo, TangibleObject* hairObject) { if (creo == NULL) return NULL; ManagedReference<TangibleObject*> hair = creo->getSlottedObject("hair").castTo<TangibleObject*>(); if (hair == hairObject) { return hairObject; } if (hair != NULL) { Locker locker(hair); hair->destroyObjectFromWorld(true); hair->destroyObjectFromDatabase(true); } if (hairObject == NULL) return NULL; // Some race condition in the client prevents both the destroy and transfer from happening too close together // Without it placing a hair object in the inventory. ManagedReference<CreatureObject*> strongCreo = creo; ManagedReference<TangibleObject*> strongHair = hairObject; Core::getTaskManager()->scheduleTask([strongCreo, strongHair]{ Locker locker(strongCreo); Locker cLocker(strongCreo, strongHair); strongCreo->transferObject(strongHair, 4); strongCreo->broadcastObject(strongHair, true); }, "TransferHairTask", 100); return hair; }
void ShipControlDeviceImplementation::storeObject(CreatureObject* player, bool force) { player->clearState(CreatureState::PILOTINGSHIP); ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get(); if (controlledObject == NULL) return; Locker clocker(controlledObject, player); if (!controlledObject->isInQuadTree()) return; Zone* zone = player->getZone(); if (zone == NULL) return; zone->transferObject(player, -1, false); controlledObject->destroyObjectFromWorld(true); transferObject(controlledObject, 4, true); updateStatus(0); }
bool SlicingSessionImplementation::hasArmorUpgradeKit() { ManagedReference<CreatureObject*> player = this->player.get(); ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get(); if (player == NULL) return false; ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory"); if (inventory == NULL) return false; for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) { ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i); uint32 objType = sceno->getGameObjectType(); if (objType == SceneObjectType::ARMORUPGRADEKIT) { Locker locker(sceno); sceno->destroyObjectFromWorld(true); sceno->destroyObjectFromDatabase(true); return true; } } return false; }
void VehicleControlDeviceImplementation::storeObject(CreatureObject* player, bool force) { ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get(); if (controlledObject == NULL) return; /*if (!controlledObject->isInQuadTree()) return;*/ if (player->isRidingMount() && player->getParent() == controlledObject) { if (!force && !player->checkCooldownRecovery("mount_dismount")) return; player->executeObjectControllerAction(STRING_HASHCODE("dismount")); if (player->isRidingMount()) return; } Locker crossLocker(controlledObject, player); controlledObject->destroyObjectFromWorld(true); if (controlledObject->isCreatureObject()) (cast<CreatureObject*>(controlledObject.get()))->setCreatureLink(NULL); updateStatus(0); }
void SlicingSessionImplementation::handleUseClamp() { ManagedReference<CreatureObject*> player = this->player.get(); ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get(); if (player == NULL || tangibleObject == NULL) return; ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory"); Locker inventoryLocker(inventory); for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) { ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i); uint32 objType = sceno->getGameObjectType(); if (objType == SceneObjectType::MOLECULARCLAMP) { Locker locker(sceno); sceno->destroyObjectFromWorld(true); sceno->destroyObjectFromDatabase(true); player->sendSystemMessage("@slicing/slicing:used_clamp"); usedClamp = true; return; } } player->sendSystemMessage("@slicing/slicing:no_clamp"); }
void CellObjectImplementation::destroyAllPlayerItems() { ManagedReference<SceneObject*> strongParent = getParent().get(); if (strongParent == NULL) return; int containerSize = getContainerObjectsSize(); for (int j = containerSize - 1; j >= 0; --j) { ReadLocker rlocker(getContainerLock()); ManagedReference<SceneObject*> containerObject = getContainerObject(j); rlocker.release(); if (strongParent->containsChildObject(containerObject)) continue; if (containerObject->isCreatureObject()) continue; containerObject->destroyObjectFromWorld(true); //containerObject->broadcastDestroy(containerObject, false); //removeObject(containerObject, false); containerObject->destroyObjectFromDatabase(true); } }
int WeaponObjectMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) { if (!sceneObject->isTangibleObject()) return 0; ManagedReference<WeaponObject*> weapon = cast<WeaponObject*>(sceneObject); if(weapon == NULL) return 1; if(weapon->isASubChildOf(player)) { if (selectedID == 69 && player->hasSkill("combat_smuggler_slicing_02")) { if (weapon->isSliced()) { player->sendSystemMessage("@slicing/slicing:already_sliced"); return 0; } ManagedReference<Facade*> facade = player->getActiveSession(SessionFacadeType::SLICING); ManagedReference<SlicingSession*> session = dynamic_cast<SlicingSession*>(facade.get()); if (session != NULL) { player->sendSystemMessage("@slicing/slicing:already_slicing"); return 0; } //Create Session session = new SlicingSession(player); session->initalizeSlicingMenu(player, weapon); return 0; } if(selectedID == 70) { weapon->repair(player); return 1; } if(selectedID == 71) { ManagedReference<PowerupObject*> pup = weapon->removePowerup(); if(pup == NULL) return 1; Locker locker(pup); pup->destroyObjectFromWorld( true ); pup->destroyObjectFromDatabase( true ); StringIdChatParameter message("powerup", "prose_remove_powerup"); //You detach your powerup from %TT. message.setTT(weapon->getDisplayedName()); player->sendSystemMessage(message); return 1; } } return TangibleObjectMenuComponent::handleObjectMenuSelect(sceneObject, player, selectedID); }
bool CreatureManagerImplementation::addWearableItem(CreatureObject* creature, TangibleObject* clothing) { if (!clothing->isWearableObject() && !clothing->isWeaponObject()) return false; ChatManager* chatMan = zoneServer->getChatManager(); SharedTangibleObjectTemplate* tanoData = dynamic_cast<SharedTangibleObjectTemplate*>(clothing->getObjectTemplate()); Vector<uint32>* races = tanoData->getPlayerRaces(); String race = creature->getObjectTemplate()->getFullTemplateString(); if(clothing->isWearableObject()) { if (!races->contains(race.hashCode())) { UnicodeString message; if(creature->getObjectTemplate()->getFullTemplateString().contains("ithorian")) message = "@player_structure:wear_not_ithorian"; else message = "@player_structure:wear_no"; chatMan->broadcastMessage(creature, message, clothing->getObjectID(), creature->getMoodID(), 0); return false; } } ManagedReference<SceneObject*> clothingParent = clothing->getParent(); if (clothingParent == NULL) return false; for (int i = 0; i < clothing->getArrangementDescriptorSize(); ++i) { Vector<String> descriptors = clothing->getArrangementDescriptor(i); for (int j = 0; j < descriptors.size(); ++j) { ManagedReference<SceneObject*> slot = creature->getSlottedObject(descriptors.get(j)); if (slot != NULL) { slot->destroyObjectFromWorld(true); slot->destroyObjectFromDatabase(true); } } } creature->transferObject(clothing, 4, false); creature->doAnimation("pose_proudly"); creature->broadcastObject(clothing, true); UnicodeString message; if(clothing->isWeaponObject()) message = "@player_structure:wear_yes_weapon"; else message = "@player_structure:wear_yes"; chatMan->broadcastMessage(creature, message, clothing->getObjectID(), creature->getMoodID(), 0); return true; }
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 PetManagerImplementation::killPet(TangibleObject* attacker, AiAgent* pet) { // TODO REMOVE AFTER TESTING bool attackerIsAdmin = false; // END REMOVE StringIdChatParameter stringId; if (attacker->isPlayerCreature()) { stringId.setStringId("base_player", "prose_target_dead"); stringId.setTT(pet->getObjectID()); (cast<CreatureObject*>(attacker))->sendSystemMessage(stringId); // TODO REMOVE AFTER TESTING //ManagedReference<PlayerObject*> ghost = (cast<CreatureObject*>(attacker))->getPlayerObject(); //if (ghost != NULL && ghost->isPrivileged()) // attackerIsAdmin = true; // END REMOVE } pet->setCurrentSpeed(0); pet->clearCombatState(true); pet->setPosture(CreaturePosture::DEAD, true); pet->updateLocomotion(); pet->updateTimeOfDeath(); pet->clearBuffs(false); ManagedReference<PetControlDevice*> petControlDevice = pet->getControlDevice().get().castTo<PetControlDevice*>(); if (petControlDevice != NULL) { if (petControlDevice->getPetType() == FACTIONPET) { ManagedReference<CreatureObject*> owner = zoneServer->getObject(pet->getCreatureLinkID()).castTo<CreatureObject*>(); if (owner != NULL) petControlDevice->storeObject(owner, true); petControlDevice->destroyObjectFromWorld(true); petControlDevice->destroyObjectFromDatabase(true); } else if ( (!attacker->isPlayerCreature() && !attacker->isPet()) || attackerIsAdmin) { // TODO REMOVE attackerIsAdmin AFTER TESTING if (pet->getCooldownTimerMap() != NULL && pet->getCooldownTimerMap()->isPast("vitalityLossCooldown")) { petControlDevice->setVitality(petControlDevice->getVitality() - 2); pet->getCooldownTimerMap()->updateToCurrentAndAddMili("vitalityLossCooldown", 300000); } } } pet->notifyObjectKillObservers(attacker); }
int InstrumentObserverImplementation::notifyObserverEvent(unsigned int eventType, Observable* observable, ManagedObject* arg1, int64 arg2) { if (eventType != ObserverEventType::POSITIONCHANGED && eventType != ObserverEventType::OBJECTREMOVEDFROMZONE) { return 0; } SceneObject* creature = cast<SceneObject*>(observable); if (creature == NULL) { return 0; } ManagedReference<Instrument* > instrument = this->instrument.get(); if (instrument == NULL || instrument->getZone() == NULL) { if (eventType == ObserverEventType::OBJECTREMOVEDFROMZONE) { creature->dropObserver(ObserverEventType::POSITIONCHANGED, _this.getReferenceUnsafeStaticCast()); } else if (eventType == ObserverEventType::POSITIONCHANGED) { creature->dropObserver(ObserverEventType::OBJECTREMOVEDFROMZONE, _this.getReferenceUnsafeStaticCast()); } return 1; } else { Locker locker(instrument); if (eventType == ObserverEventType::POSITIONCHANGED) { if (creature->getDistanceTo(instrument) > 8) { instrument->destroyObjectFromWorld(true); creature->dropObserver(ObserverEventType::OBJECTREMOVEDFROMZONE, _this.getReferenceUnsafeStaticCast()); return 1; } } else if (eventType == ObserverEventType::OBJECTREMOVEDFROMZONE) { instrument->destroyObjectFromWorld(true); creature->dropObserver(ObserverEventType::POSITIONCHANGED, _this.getReferenceUnsafeStaticCast()); return 1; } } return 0; }
void CityRegionImplementation::destroyActiveAreas() { for (int i = 0; i < regions.size(); ++i) { ManagedReference<Region*> aa = regions.get(i); if (aa != NULL) { Locker clocker(aa, _this.getReferenceUnsafeStaticCast()); aa->destroyObjectFromWorld(false); aa->destroyObjectFromDatabase(true); } } regions.removeAll(); }
void FireworkObjectImplementation::beginShowLaunch(CreatureObject* player) { if (player == NULL || player->getParent() != NULL) return; ManagedReference<FireworkObject*> fireworkShow = _this.getReferenceUnsafeStaticCast(); if (fireworkShow == NULL) return; DataObjectComponent* data = fireworkShow->getDataObjectComponent()->get(); if(data == NULL || !data->isFireworkShowData()) return; FireworkShowDataComponent* fireworkShowData = cast<FireworkShowDataComponent*>(data); if (fireworkShowData->getTotalFireworkCount() == 0) return; ManagedReference<StaticObject*> showLauncherObject = (getZoneServer()->createObject(fireworkObject.hashCode(), 0)).castTo<StaticObject*>(); if (showLauncherObject == NULL) return; player->setPosture(CreaturePosture::CROUCHED); player->doAnimation("manipulate_low"); float angle = player->getDirectionAngle(); if (angle > 360) angle = angle - 360; float distance = 2.0; angle = 2 * M_PI * angle / 360; int x = player->getPositionX() + sin(angle) * (distance); int y = player->getPositionY() + cos(angle) * (distance); int z = player->getZone()->getHeight(x, y); Locker locker(showLauncherObject); showLauncherObject->initializePosition(x, z, y); player->getZone()->transferObject(showLauncherObject, -1, true); fireworkShow->destroyObjectFromWorld(true); int launchDelay = fireworkShowData->getFireworkDelay(0); Reference<FireworkShowLaunchFireworkEvent*> fireworkShowLaunchFireworkEvent = new FireworkShowLaunchFireworkEvent(player, fireworkShow, fireworkShowData, showLauncherObject); fireworkShowLaunchFireworkEvent->schedule(launchDelay); }
void DestroyMissionObjectiveImplementation::destroyObjectFromDatabase() { MissionObjectiveImplementation::destroyObjectFromDatabase(); ManagedReference<MissionSpawnActiveArea* > spawnActiveArea = this->spawnActiveArea; if (spawnActiveArea != NULL) { Locker locker(spawnActiveArea); spawnActiveArea->destroyObjectFromWorld(true); spawnActiveArea->destroyObjectFromDatabase(true); this->spawnActiveArea = NULL; } }
void CityRegionImplementation::removeAllDecorations() { Locker slocker(&structureListMutex); for (int i = cityDecorations.size() - 1; i >= 0 ; --i) { ManagedReference<SceneObject*> dec = cityDecorations.get(i); if(dec->isStructureObject()) { StructureManager::instance()->destroyStructure(cast<StructureObject*>(dec.get())); } else { dec->destroyObjectFromWorld(false); dec->destroyObjectFromDatabase(true); } } cityDecorations.removeAll(); }
void SceneObjectImplementation::destroyChildObjects() { int size = childObjects.size(); for (int i = 0; i < size; i++) { ManagedReference<SceneObject*> child = childObjects.get(0); if (child == NULL) continue; Locker clocker(child, asSceneObject()); childObjects.drop(child); child->destroyObjectFromDatabase(true); child->destroyObjectFromWorld(true); } }
void WeaponObjectImplementation::decreasePowerupUses(CreatureObject* player) { if (hasPowerup()) { powerupObject->decreaseUses(); if (powerupObject->getUses() < 1) { Locker locker(_this.getReferenceUnsafeStaticCast()); StringIdChatParameter message("powerup", "prose_pup_expire"); //The powerup on your %TT has expired. message.setTT(getDisplayedName()); player->sendSystemMessage(message); ManagedReference<PowerupObject*> pup = removePowerup(); if(pup != NULL) { Locker plocker(pup); pup->destroyObjectFromWorld( true ); pup->destroyObjectFromDatabase( true ); } } sendAttributeListTo(player); } }
void SlicingSessionImplementation::handleUseFlowAnalyzer() { ManagedReference<CreatureObject*> player = this->player.get(); ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get(); if (player == NULL || tangibleObject == NULL) return; ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory"); Locker inventoryLocker(inventory); for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) { ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i); uint32 objType = sceno->getGameObjectType(); if (objType == SceneObjectType::FLOWANALYZER) { SlicingTool* node = cast<SlicingTool*>( sceno.get()); nodeCable = node->calculateSuccessRate(); if (nodeCable) // PASSED nodeCable = firstCable; else if (nodeCable == firstCable) { // Failed but the cables are Correct if (firstCable) nodeCable = 0; // Failed - Make the Cable incorrect } Locker locker(sceno); sceno->destroyObjectFromWorld(true); sceno->destroyObjectFromDatabase(true); player->sendSystemMessage("@slicing/slicing:used_node"); usedNode = true; return; } } player->sendSystemMessage("@slicing/slicing:no_node"); }
TangibleObject* ImageDesignManager::updateHairObject(CreatureObject* creo, TangibleObject* hairObject) { if (creo == NULL) return NULL; ManagedReference<TangibleObject*> hair = creo->getSlottedObject("hair").castTo<TangibleObject*>(); if (hair != NULL) { Locker locker(hair); hair->destroyObjectFromWorld(true); hair->destroyObjectFromDatabase(true); } if (hairObject == NULL) return NULL; Locker locker(hairObject); creo->transferObject(hairObject, 4); creo->broadcastObject(hairObject, true); return hair; }
void CreateVendorSessionImplementation::randomizeVendorClothing(CreatureObject* vendor, VendorCreatureTemplate* vendorTempl) { String randomOutfit = vendorTempl->getOutfitName(System::random(vendorTempl->getOutfitsSize() -1)); if (randomOutfit.isEmpty()) return; Reference<Outfit*> outfit = VendorOutfitManager::instance()->getOutfit(randomOutfit); if (outfit == NULL) return; Vector<uint32>* clothing = outfit->getClothing(); for (int i = 0; i < clothing->size(); ++i) { ManagedReference<SceneObject*> obj = player->getZoneServer()->createObject(clothing->get(i), 1); if (obj == NULL) continue; for (int j = 0; j < obj->getArrangementDescriptorSize(); ++j) { const Vector<String>* descriptors = obj->getArrangementDescriptor(j); for (int k = 0; k < descriptors->size(); ++k) { ManagedReference<SceneObject*> slot = vendor->getSlottedObject(descriptors->get(k)); if (slot != NULL) { slot->destroyObjectFromWorld(true); slot->destroyObjectFromDatabase(true); } } } if (!vendor->transferObject(obj, 4)) { obj->destroyObjectFromDatabase(true); } } }
bool ZoneContainerComponent::removeObject(SceneObject* sceneObject, SceneObject* object, SceneObject* destination, bool notifyClient) { Zone* zone = dynamic_cast<Zone*>(sceneObject); if (object->isActiveArea()) return removeActiveArea(zone, dynamic_cast<ActiveArea*>(object)); ManagedReference<SceneObject*> parent = object->getParent(); //SortedVector<ManagedReference<SceneObject*> >* notifiedSentObjects = sceneObject->getNotifiedSentObjects(); try { Locker locker(object); if (zone == NULL) return false; object->info("removing from zone"); Locker zoneLocker(zone); if (parent != NULL) { parent->removeObject(object, NULL, false); } else zone->remove(object); Zone* oldZone = zone; // oldZone->dropSceneObject(object); // zoneLocker.release(); SortedVector<ManagedReference<QuadTreeEntry*> >* closeObjects = object->getCloseObjects(); if (closeObjects != NULL) { try { while (closeObjects->size() > 0) { ManagedReference<QuadTreeEntry*> obj = closeObjects->get(0); if (obj != NULL && obj != object && obj->getCloseObjects() != NULL) obj->removeInRangeObject(object); object->removeInRangeObject((int) 0); } } catch (...) { } } else { object->info("Null closeobjects vector in ZoneContainerComponent::removeObject", true); SortedVector<ManagedReference<QuadTreeEntry*> > closeSceneObjects; zone->getInRangeObjects(object->getPositionX(), object->getPositionY(), 512, &closeSceneObjects, false); for (int i = 0; i < closeSceneObjects.size(); ++i) { QuadTreeEntry* obj = closeSceneObjects.get(i); if (obj != NULL && obj != object && obj->getCloseObjects() != NULL) obj->removeInRangeObject(object); } } // Zone* oldZone = zone; zone = NULL; oldZone->dropSceneObject(object); SharedBuildingObjectTemplate* objtemplate = dynamic_cast<SharedBuildingObjectTemplate*>(object->getObjectTemplate()); if (objtemplate != NULL) { String modFile = objtemplate->getTerrainModificationFile(); if (!modFile.isEmpty()) { oldZone->getPlanetManager()->getTerrainManager()->removeTerrainModification(object->getObjectID()); } } zoneLocker.release(); if (object->isTangibleObject()) { TangibleObject* tano = cast<TangibleObject*>(object); Vector<ManagedReference<ActiveArea*> >* activeAreas = tano->getActiveAreas(); while (activeAreas->size() > 0) { Locker _alocker(object->getContainerLock()); ManagedReference<ActiveArea*> area = activeAreas->get(0); activeAreas->remove(0); _alocker.release(); area->enqueueExitEvent(object); } } SortedVector<ManagedReference<SceneObject*> >* childObjects = object->getChildObjects(); //Remove all outdoor child objects from zone for (int i = 0; i < childObjects->size(); ++i) { ManagedReference<SceneObject*> outdoorChild = childObjects->get(i); if (outdoorChild == NULL) continue; if (outdoorChild->isInQuadTree()) { Locker locker(outdoorChild); outdoorChild->destroyObjectFromWorld(true); } } } catch (Exception& e) { } object->notifyObservers(ObserverEventType::OBJECTREMOVEDFROMZONE, NULL, 0); VectorMap<uint32, ManagedReference<Facade*> >* objectActiveSessions = object->getObjectActiveSessions(); while (objectActiveSessions->size()) { ManagedReference<Facade*> facade = objectActiveSessions->remove(0).getValue(); if (facade == NULL) continue; facade->cancelSession(); } //activeAreas.removeAll(); object->info("removed from zone"); object->notifyRemoveFromZone(); object->setZone(NULL); return true; }
void DroidDeedImplementation::updateCraftingValues(CraftingValues* values, bool firstUpdate) { /* * Values available: Range: * */ String key; ManagedReference<DroidComponent*> comp = NULL; HashTableIterator<String, ManagedReference<DroidComponent*> > iterator = modules.iterator(); for(int i = 0; i < modules.size(); ++i) { iterator.getNextKeyAndValue(key, comp); if (comp) { comp->destroyObjectFromWorld(true); comp->destroyObjectFromDatabase(true); } } modules.removeAll(); overallQuality = values->getCurrentPercentage("power_level"); // effectiveness if (overallQuality < 0) overallQuality = 0.1; combatRating = values->getCurrentValue("cmbt_module"); if (combatRating < 0) combatRating = 0; // @TODO Add crafting values, this should adjust toHit and Speed based on droid ham, also // we need to stack modules if they are stackable. // walk all components and ensure we have all modules that are stackable there. ManagedReference<ManufactureSchematic*> manufact = values->getManufactureSchematic(); for (int i = 0; i < manufact->getSlotCount(); ++i) { // Droid Component Slots Reference<IngredientSlot* > iSlot = manufact->getSlot(i); if (iSlot->isComponentSlot()) { ComponentSlot* cSlot = cast<ComponentSlot*>(iSlot.get()); ManagedReference<TangibleObject*> tano = cSlot->getPrototype(); ManagedReference<DroidComponent*> component = cast<DroidComponent*>( tano.get()); // only check modules if (component != NULL) { if (component->isSocketCluster()) { // pull out the objects ManagedReference<SceneObject*> craftingComponents = component->getSlottedObject("crafted_components"); if(craftingComponents != NULL) { SceneObject* satchel = craftingComponents->getContainerObject(0); for (int i = 0; i < satchel->getContainerObjectsSize(); ++i) { ManagedReference<SceneObject*> sceno = satchel->getContainerObject(i); if (sceno != NULL) { // now we have the componet used in this socket item ManagedReference<DroidComponent*> sub = cast<DroidComponent*>( sceno.get()); if (sub != NULL) { DataObjectComponentReference* data = sub->getDataObjectComponent(); BaseDroidModuleComponent* module = NULL; if(data != NULL && data->get() != NULL && data->get()->isDroidModuleData() ){ module = cast<BaseDroidModuleComponent*>(data->get()); } if (module == NULL) { continue; } processModule(module,sceno->getServerObjectCRC()); } } } } } else { DataObjectComponentReference* data = component->getDataObjectComponent(); BaseDroidModuleComponent* module = NULL; if(data != NULL && data->get() != NULL && data->get()->isDroidModuleData() ){ module = cast<BaseDroidModuleComponent*>(data->get()); } if (module == NULL) { continue; } processModule(module,tano->getServerObjectCRC()); } } } } // module stacking is completed! }
void SlicingSessionImplementation::handleContainerSlice() { ManagedReference<CreatureObject*> player = this->player.get(); ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get(); if (tangibleObject == NULL || player == NULL) return; ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory"); if (inventory == NULL) return; Locker inventoryLocker(inventory); LootManager* lootManager = player->getZoneServer()->getLootManager(); if (tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE) { Reference<SceneObject*> containerSceno = player->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/container/loot/loot_crate.iff"), 1); if (containerSceno == NULL) return; Locker clocker(containerSceno, player); Container* container = dynamic_cast<Container*>(containerSceno.get()); if (container == NULL) { containerSceno->destroyObjectFromDatabase(true); return; } if (System::random(10) != 4) lootManager->createLoot(container, "looted_container"); inventory->transferObject(container, -1); container->sendTo(player, true); if (inventory->hasObjectInContainer(tangibleObject->getObjectID())) { //inventory->removeObject(tangibleObject, true); tangibleObject->destroyObjectFromWorld(true); } tangibleObject->destroyObjectFromDatabase(true); } else if (tangibleObject->isContainerObject()) { Container* container = dynamic_cast<Container*>(tangibleObject.get()); if (container == NULL) return; container->setSliced(true); container->setLockedStatus(false); if(!container->isRelocking()) { relockEvent = new RelockLootContainerEvent(container); relockEvent->schedule(container->getLockTime()); } } else return; player->sendSystemMessage("@slicing/slicing:container_success"); }
void DestroyMissionObjectiveImplementation::spawnLair() { ManagedReference<MissionObject* > mission = this->mission.get(); ManagedReference<MissionSpawnActiveArea* > spawnActiveArea = this->spawnActiveArea; if (spawnActiveArea == NULL) return; if (lairObject != NULL && lairObject->getZone() != NULL) return; Zone* zone = spawnActiveArea->getZone(); Locker locker(spawnActiveArea); spawnActiveArea->destroyObjectFromWorld(true); Vector3 pos = findValidSpawnPosition(zone); ManagedReference<WaypointObject*> waypoint = mission->getWaypointToMission(); if (waypoint == NULL) { waypoint = mission->createWaypoint(); } waypoint->setPosition(pos.getX(), 0, pos.getY()); mission->updateMissionLocation(); mission->setStartPosition(pos.getX(), pos.getY()); //TODO: find correct string id ManagedReference<CreatureObject*> player = getPlayerOwner(); if (player != NULL) { player->sendSystemMessage("Transmission Received: Mission Target has been located. Mission waypoint has been updated to exact location"); } LairTemplate* lair = CreatureTemplateManager::instance()->getLairTemplate(lairTemplate.hashCode()); if (lair == NULL) { error("incorrect lair template in destroy mission objective " + lairTemplate); abort(); return; } if (lairObject == NULL) { String buildingToSpawn = lair->getMissionBuilding(difficulty); if (buildingToSpawn.isEmpty()) { error("error spawning " + buildingToSpawn); abort(); return; } lairObject = zone->getZoneServer()->createObject(buildingToSpawn.hashCode(), 0).castTo<LairObject*>(); if (lairObject == NULL) { error("error spawning " + buildingToSpawn); abort(); return; } Locker locker(lairObject); lairObject->setFaction(lair->getFaction()); lairObject->setPvpStatusBitmask(CreatureFlag::ATTACKABLE); lairObject->setOptionsBitmask(0, false); lairObject->setMaxCondition(difficultyLevel * (900 + System::random(200))); lairObject->setConditionDamage(0, false); lairObject->initializePosition(pos.getX(), pos.getZ(), pos.getY()); lairObject->setDespawnOnNoPlayersInRange(false); ManagedReference<MissionObserver*> observer = new MissionObserver(_this.get()); addObserver(observer, true); lairObject->registerObserver(ObserverEventType::OBJECTDESTRUCTION, observer); ManagedReference<DestroyMissionLairObserver*> lairObserver = new DestroyMissionLairObserver(); lairObserver->deploy(); lairObserver->setLairTemplate(lair); lairObserver->setDifficulty(difficulty); lairObserver->setObserverType(ObserverType::LAIR); lairObserver->setSize(mission->getSize()); lairObject->registerObserver(ObserverEventType::OBJECTDESTRUCTION, lairObserver); lairObject->registerObserver(ObserverEventType::DAMAGERECEIVED, lairObserver); lairObject->registerObserver(ObserverEventType::AIMESSAGE, lairObserver); lairObject->registerObserver(ObserverEventType::OBJECTREMOVEDFROMZONE, lairObserver); zone->transferObject(lairObject, -1, true); lairObserver->checkForNewSpawns(lairObject, NULL, true); } if (lairObject != NULL && lairObject->getZone() == NULL) { zone->transferObject(lairObject, -1, true); } }
void TangibleObjectImplementation::repair(CreatureObject* player) { if(player == NULL || player->getZoneServer() == NULL) return; if(!isASubChildOf(player)) return; if (getConditionDamage() == 0) { player->sendSystemMessage("That item is not in need of repair."); return; } //Condition is unrepairable if ((getMaxCondition() - getConditionDamage()) <= 0) { StringIdChatParameter cantrepair("error_message", "sys_repair_unrepairable"); cantrepair.setTT(getDisplayedName()); player->sendSystemMessage(cantrepair); //%TT's condition is beyond repair even for your skills. return; } SceneObject* inventory = player->getSlottedObject("inventory"); if(inventory == NULL) return; ManagedReference<RepairTool*> repairTool = NULL; Reference<RepairToolTemplate*> repairTemplate = NULL; for(int i = 0; i < inventory->getContainerObjectsSize(); ++i) { ManagedReference<SceneObject*> item = inventory->getContainerObject(i); if(item->isRepairTool()) { repairTemplate = cast<RepairToolTemplate*>(item->getObjectTemplate()); if (repairTemplate == NULL) { error("No RepairToolTemplate for: " + String::valueOf(item->getServerObjectCRC())); return; } if(repairTemplate->getRepairType() & getGameObjectType()) { repairTool = cast<RepairTool*>(item.get()); break; } repairTemplate = NULL; } } if(repairTool == NULL) return; /// Luck Roll + Profession Mod(25) + Luck Tapes /// + Station Mod - BF /// Luck Roll int roll = System::random(100); int repairChance = roll; /// Profession Bonus if(player->hasSkill(repairTemplate->getSkill())) repairChance += 35; /// Get Skill mods repairChance += player->getSkillMod(repairTemplate->getSkillMod()); repairChance += player->getSkillMod("crafting_repair"); repairChance += player->getSkillMod("force_repair_bonus"); /// use tool quality to lower chances if bad tool float quality = 1.f - (((100.f - repairTool->getQuality()) / 2) / 100.f); repairChance *= quality; ManagedReference<PlayerManager*> playerMan = player->getZoneServer()->getPlayerManager(); /// Increase if near station if(playerMan->getNearbyCraftingStation(player, repairTemplate->getStationType()) != NULL) { repairChance += 15; } /// Subtract battle fatigue repairChance -= (player->getShockWounds() / 2); /// Subtract complexity repairChance -= (getComplexity() / 3); /// 5% random failure if(getMaxCondition() < 20 || roll < 5) repairChance = 0; if(roll > 95) repairChance = 100; String result = repairAttempt(repairChance); Locker locker(repairTool); repairTool->destroyObjectFromWorld(true); repairTool->destroyObjectFromDatabase(true); player->sendSystemMessage(result); }