void SuiManager::handleStartDancing(CreatureObject* player, SuiBox* suiBox, uint32 cancel, Vector<UnicodeString>* args) { if (!suiBox->isListBox() || cancel != 0) return; if (args->size() < 2) return; int index = Integer::valueOf(args->get(0).toString()); uint32 id = suiBox->getBoxID(); bool change = (uint16)id == SuiWindowType::DANCING_CHANGE; SuiListBox* listBox = cast<SuiListBox*>( suiBox); if (index == -1) return; String dance = listBox->getMenuItemName(index); if (!change) player->executeObjectControllerAction(STRING_HASHCODE("startdance"), 0, dance); else player->executeObjectControllerAction(STRING_HASHCODE("changedance"), 0, dance); }
bool CreatureManagerImplementation::createCreatureChildrenObjects(CreatureObject* creature, uint32 templateCRC, bool persistent, uint32 mobileTemplateCRC) { if (creature->hasSlotDescriptor("default_weapon")) { uint32 defaultWeaponCRC = 0; if (creature->isNonPlayerCreatureObject()) { defaultWeaponCRC = STRING_HASHCODE("object/weapon/melee/unarmed/unarmed_default.iff"); } else { defaultWeaponCRC = STRING_HASHCODE("object/weapon/creature/creature_default_weapon.iff"); } ManagedReference<SceneObject*> defaultWeapon = zoneServer->createObject(defaultWeaponCRC, persistent); ManagedReference<SceneObject*> otherWeapon; if(mobileTemplateCRC != 0) { CreatureTemplate* creoTempl = creatureTemplateManager->getTemplate(mobileTemplateCRC); if(creoTempl != NULL && creoTempl->getDefaultWeapon() != ""){ uint32 otherWeaponCRC = String(creoTempl->getDefaultWeapon()).hashCode(); otherWeapon = zoneServer->createObject(otherWeaponCRC, persistent); } } if(otherWeapon != NULL) { if (defaultWeapon != NULL && defaultWeapon->isPersistent()) { Locker clocker(defaultWeapon, creature); defaultWeapon->destroyObjectFromDatabase(true); } defaultWeapon = otherWeapon; } if (defaultWeapon == NULL) { error("could not create creature default weapon"); return false; } Locker clocker(defaultWeapon, creature); creature->transferObject(defaultWeapon, 4); } if (creature->hasSlotDescriptor("inventory")) { Reference<SceneObject*> creatureInventory = zoneServer->createObject(STRING_HASHCODE("object/tangible/inventory/creature_inventory.iff"), persistent); if (creatureInventory == NULL) { error("could not create creature inventory"); return false; } Locker clocker(creatureInventory, creature); creatureInventory->setContainerDefaultDenyPermission(ContainerPermissions::MOVECONTAINER); creatureInventory->setContainerDenyPermission("owner", ContainerPermissions::MOVECONTAINER); creatureInventory->setContainerInheritPermissionsFromParent(false); creature->transferObject(creatureInventory, 4); } return true; }
void SuiManager::handleStartMusic(CreatureObject* player, SuiBox* suiBox, uint32 cancel, Vector<UnicodeString>* args) { if (!suiBox->isListBox() || cancel != 0) return; if (args->size() < 2) return; int index = Integer::valueOf(args->get(0).toString()); uint32 id = suiBox->getBoxID(); SuiListBox* listBox = cast<SuiListBox*>( suiBox); if (index == -1) return; String dance = listBox->getMenuItemName(index); switch ((uint16)id) { case SuiWindowType::MUSIC_START: player->executeObjectControllerAction(STRING_HASHCODE("startmusic"), player->getTargetID(), dance); break; case SuiWindowType::MUSIC_CHANGE: player->executeObjectControllerAction(STRING_HASHCODE("changemusic"), player->getTargetID(), dance); break; case SuiWindowType::BAND_CHANGE: player->executeObjectControllerAction(STRING_HASHCODE("changebandmusic"), player->getTargetID(), dance); break; case SuiWindowType::BAND_START: player->executeObjectControllerAction(STRING_HASHCODE("startband"), player->getTargetID(), dance); break; } }
void ObjectVersionUpdateManager::updateCityTreasuryToDouble(){ info("---------------MOdifying City Treasury---------------------",true); info("Converting treasury to double for all cities ", true); ObjectDatabase* database = ObjectDatabaseManager::instance()->loadObjectDatabase("cityregions", true); ObjectInputStream objectData(2000); String className; ObjectDatabaseIterator iterator(database); uint64 objectID = 0; int count = 0; try { while (iterator.getNextKeyAndValue(objectID, &objectData)) { String className; try { if (!Serializable::getVariable<String>(STRING_HASHCODE("_className"), &className, &objectData)) { objectData.clear(); continue; } } catch (...) { objectData.clear(); continue; } float funds; double floatFunds = 5; if (className == "CityRegion") { count++; printf("\r\tUpdating city treasury [%d] / [?]\t", count); if ( Serializable::getVariable<float>(STRING_HASHCODE("CityRegion.cityTreasury"), &funds, &objectData)){ floatFunds = funds; ObjectOutputStream newFunds; TypeInfo<double>::toBinaryStream(&floatFunds, &newFunds ); ObjectOutputStream* test = changeVariableData(STRING_HASHCODE("CityRegion.cityTreasury"), &objectData, &newFunds); test->reset(); database->putData(objectID, test, NULL); } else { info("Error... city " + String::valueOf(objectID) + " doesn't have cityTreasury variable",true); } } objectData.clear(); } } catch (Exception& e) { error(e.getMessage()); e.printStackTrace(); } }
void ObjectVersionUpdateManager::updateResidences(){ ObjectDatabase* database = ObjectDatabaseManager::instance()->loadObjectDatabase("sceneobjects", true); ObjectDatabaseIterator iterator(database); ObjectInputStream objectData(2000); uint64 objectID = 0; info("---------------Setting residences---------------------",true); info("Setting residence values for all active player residences ", true); int count = 0; try { while (iterator.getNextKeyAndValue(objectID, &objectData)) { String className; uint64 residence = 0; try { if (!Serializable::getVariable<String>(STRING_HASHCODE("_className"), &className, &objectData) || !Serializable::getVariable<uint64>(STRING_HASHCODE("PlayerObject.declaredResidence"), &residence, &objectData)) { objectData.clear(); continue; } } catch (...) { objectData.clear(); continue; } if (className == "PlayerObject") { // info("we found a Player " + String::valueOf(objectID) + " with residence " + String::valueOf(residence),true); SortedVector<unsigned long long> structureList; uint64 residence = 0; count++; printf("\r\tUpdating player residence [%d] / [?]\t", count); if( Serializable::getVariable< SortedVector<unsigned long long> >(STRING_HASHCODE("PlayerObject.ownedStructures"), &structureList, &objectData) && Serializable::getVariable<uint64>(STRING_HASHCODE("PlayerObject.declaredResidence"), &residence, &objectData)){ for(int i = 0; i < structureList.size(); i++){ bool isRes = (structureList.get(i) == residence); //info("Owned structure " + String::valueOf(structureList.get(i)) + " residence = " + String::valueOf(isRes),true); setResidence(structureList.get(i),isRes); } } else { info("ERROR unable to get ownedStructures for player " + String::valueOf(objectID),true); } } objectData.clear(); } } catch (Exception& e) { error(e.getMessage()); e.printStackTrace(); } info("\n",true); }
int SarlaccMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) const { if (selectedID == 20) { Locker plocker(player, sceneObject); ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory"); if (inventory->isContainerFullRecursive()) { player->sendSystemMessage("@error_message:inv_full"); // Your inventory is full. return 0; } SceneObject* sco = NULL; for (int i=0; i< inventory->getContainerObjectsSize(); i++) { sco = inventory->getContainerObject(i); if (sco == NULL) continue; if (sco->getServerObjectCRC() == STRING_HASHCODE("object/tangible/loot/quest/quest_item_sarlacc_bile_jar.iff")) { player->sendSystemMessage("@mob/sarlacc:bile_already"); // You already have a good sample of bile. It probably isn't wise to risk getting more. return 0; } if (sco->getContainerObjectsSize() > 0) { for (int j=0; j < sco->getContainerObjectsSize(); j++) { SceneObject* child = sco->getContainerObject(j); if (child == NULL) continue; if (child->getServerObjectCRC() == STRING_HASHCODE("object/tangible/loot/quest/quest_item_sarlacc_bile_jar.iff")) { player->sendSystemMessage("@mob/sarlacc:bile_already"); // You already have a good sample of bile. It probably isn't wise to risk getting more. return 0; } } } } if( !player->getCooldownTimerMap()->isPast("extractBileCooldown") ){ player->sendSystemMessage("@mob/sarlacc:bile_fail"); // You fail to find enough bile to collect. You need to wait for more to accumulate. return 0; } Reference<SceneObject*> bileSceno = player->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/loot/quest/quest_item_sarlacc_bile_jar.iff"), 1); if (bileSceno == NULL) return 1; if (inventory->transferObject(bileSceno, -1)) { inventory->broadcastObject(bileSceno, true); player->sendSystemMessage("@mob/sarlacc:bile_success"); // Despite being nearly overwhelmed by the stench of decay and the reaching tentacles, you manage to collect a sufficient sample of bile. player->getCooldownTimerMap()->updateToCurrentAndAddMili("extractBileCooldown", 1000 * 60 * 30); // 30 min cooldown return 0; } else { bileSceno->destroyObjectFromDatabase(true); return 1; } } return 0; }
void PetControlDeviceImplementation::storeObject(CreatureObject* player, bool force) { ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get(); if (controlledObject == NULL || !controlledObject->isAiAgent()) return; ManagedReference<AiAgent*> pet = cast<AiAgent*>(controlledObject.get()); assert(pet->isLockedByCurrentThread()); if (!force && (pet->isInCombat() || player->isInCombat())) return; if (player->isRidingMount() && player->getParent() == pet) { if (!force && !player->checkCooldownRecovery("mount_dismount")) return; player->executeObjectControllerAction(STRING_HASHCODE("dismount")); if (player->isRidingMount()) return; } if( player->getCooldownTimerMap() == NULL ) return; // Check cooldown if( !player->getCooldownTimerMap()->isPast("petCallOrStoreCooldown") && !force ){ player->sendSystemMessage("@pet/pet_menu:cant_store_1sec"); //"You cannot STORE for 1 second." return; } // Not training any commands trainingCommand = 0; Reference<StorePetTask*> task = new StorePetTask(player, pet); // Store non-faction pets immediately. Store faction pets after 60sec delay. if( petType != PetManager::FACTIONPET || force || player->getPlayerObject()->isPrivileged()){ task->execute(); } else{ if(pet->getPendingTask("store_pet") == NULL) { player->sendSystemMessage( "Storing pet in 60 seconds"); pet->addPendingTask("store_pet", task, 60 * 1000); } else{ Time nextExecution; Core::getTaskManager()->getNextExecutionTime(pet->getPendingTask("store_pet"), nextExecution); int timeLeft = (nextExecution.getMiliTime() / 1000) - System::getTime(); player->sendSystemMessage( "Pet will store in " + String::valueOf(timeLeft) + " seconds." ); return; } } // Set cooldown player->getCooldownTimerMap()->updateToCurrentAndAddMili("petCallOrStoreCooldown", 1000); // 1 sec }
void PlanetManagerImplementation::loadBadgeAreas(LuaObject* badges) { if (!badges->isValidTable()) return; uint32 hashCode = STRING_HASHCODE("object/badge_area.iff"); for (int i = 1; i <= badges->getTableSize(); ++i) { lua_State* L = badges->getLuaState(); lua_rawgeti(L, -1, i); LuaObject badge(L); String badgeName = badge.getStringAt(1); float x = badge.getFloatAt(2); float y = badge.getFloatAt(3); float radius = badge.getFloatAt(4); int badgeID = badge.getIntAt(5); ManagedReference<BadgeActiveArea*> obj = server->getZoneServer()->createObject(hashCode, 0).castTo<BadgeActiveArea*>(); Locker objLocker(obj); obj->setRadius(radius); obj->setBadge(badgeID); obj->initializePosition(x, 0, y); zone->transferObject(obj, -1, false); badge.pop(); } }
Reference<SceneObject*> PlanetManagerImplementation::createTicket(const String& departurePoint, const String& arrivalPlanet, const String& arrivalPoint) { ManagedReference<SceneObject*> obj = server->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/travel/travel_ticket/base/base_travel_ticket.iff"), 1); if (obj == NULL) return NULL; if (!obj->isTangibleObject()) { obj->destroyObjectFromDatabase(true); return NULL; } TangibleObject* tano = cast<TangibleObject*>( obj.get()); if (!tano->isTicketObject()) { tano->destroyObjectFromDatabase(true); return NULL; } TicketObject* ticket = cast<TicketObject*>( tano); ticket->setDeparturePlanet(zone->getZoneName()); ticket->setDeparturePoint(departurePoint); ticket->setArrivalPlanet(arrivalPlanet); ticket->setArrivalPoint(arrivalPoint); return ticket; }
void PetControlDeviceImplementation::destroyObjectFromDatabase(bool destroyContainedObjects) { ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get(); if (controlledObject != NULL) { Locker locker(controlledObject); ManagedReference<CreatureObject*> object = controlledObject->getSlottedObject("rider").castTo<CreatureObject*>(); if (object != NULL) { Locker clocker(object, controlledObject); object->executeObjectControllerAction(STRING_HASHCODE("dismount")); object = controlledObject->getSlottedObject("rider").castTo<CreatureObject*>(); if (object != NULL) { controlledObject->removeObject(object, NULL, true); Zone* zone = getZone(); if (zone != NULL) zone->transferObject(object, -1, false); } } controlledObject->destroyObjectFromDatabase(true); } IntangibleObjectImplementation::destroyObjectFromDatabase(destroyContainedObjects); }
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 DeliverMissionObjectiveImplementation::updateMissionStatus(CreatureObject* player) { ManagedReference<MissionObject* > mission = this->mission.get(); if(mission == NULL) return; StringBuffer itemEntry; itemEntry << "m" << mission->getMissionNumber(); ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory"); StringId itemName; Locker lock(player); if (objectiveStatus == 0) { itemEntry << "l"; item = NULL; //TODO: create correct item. item = (player->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/mission/mission_datadisk.iff"), 2)).castTo<TangibleObject*>(); if (item == NULL) { abort(); return; } Locker clocker(item, player); itemName.setStringId("mission/mission_deliver_neutral_easy", itemEntry.toString()); item->setObjectName(itemName, false); //Give player the item to deliver if (inventory->transferObject(item, -1, true)) { item->sendTo(player, true); } else { abort(); item->destroyObjectFromDatabase(true); return; } updateMissionTarget(player); objectiveStatus = PICKEDUPSTATUS; } else if (objectiveStatus == 1) { // check for item, then remove item if (item == NULL || !inventory->hasObjectInContainer(item->getObjectID())) { return; } Locker clocker2(item, player); item->destroyObjectFromWorld(true); item->destroyObjectFromDatabase(true); complete(); objectiveStatus = DELIVEREDSTATUS; } }
void FishingPoleObjectImplementation::doFishing(CreatureObject* player) { ManagedReference<FishingManager*> manager = server->getFishingManager(); if (manager->getFishingState(player) != FishingManager::NOTFISHING) { manager->stopFishing(player, manager->getFishBoxID(player), true); } else { //manager->freeBait(player); player->executeObjectControllerAction(STRING_HASHCODE("fish")); } }
int VehicleObjectImplementation::notifyObjectDestructionObservers(TangibleObject* attacker, int condition) { unlock(); ManagedReference<CreatureObject* > linkedCreature = this->linkedCreature.get(); if (linkedCreature != NULL) { linkedCreature->sendSystemMessage("@pet/pet_menu:veh_disabled"); ManagedReference<VehicleObject*> vehicle = _this.getReferenceUnsafeStaticCast(); String vehicleName = vehicle->getDisplayedName(); if (!vehicleName.beginsWith("(disabled)")) { UnicodeString disabledName = "(disabled) " + vehicleName; vehicle->setCustomObjectName(disabledName, true); } try { if (attacker != _this.getReferenceUnsafeStaticCast()) { Locker clocker(linkedCreature, attacker); linkedCreature->updateCooldownTimer("mount_dismount", 0); linkedCreature->executeObjectControllerAction(STRING_HASHCODE("dismount")); } else { Locker locker(linkedCreature); linkedCreature->updateCooldownTimer("mount_dismount", 0); linkedCreature->executeObjectControllerAction(STRING_HASHCODE("dismount")); } } catch (Exception& e) { } } if (attacker != _this.getReferenceUnsafeStaticCast()) wlock(attacker); else wlock(); return CreatureObjectImplementation::notifyObjectDestructionObservers(attacker, condition); }
void VehicleControlDeviceImplementation::spawnObject(CreatureObject* player) { ZoneServer* zoneServer = getZoneServer(); ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get(); if (controlledObject == NULL) return; if (!isASubChildOf(player)) return; if (player->getParent() != NULL || player->isInCombat()) { player->sendSystemMessage("@pet/pet_menu:cant_call_vehicle"); // You can only unpack vehicles while Outside and not in Combat. return; } ManagedReference<TradeSession*> tradeContainer = player->getActiveSession(SessionFacadeType::TRADE).castTo<TradeSession*>(); if (tradeContainer != NULL) { server->getZoneServer()->getPlayerManager()->handleAbortTradeMessage(player); } controlledObject->initializePosition(player->getPositionX(), player->getPositionZ(), player->getPositionY()); ManagedReference<CreatureObject*> vehicle = NULL; if (controlledObject->isCreatureObject()) { vehicle = cast<CreatureObject*>(controlledObject.get()); vehicle->setCreatureLink(player); vehicle->setControlDevice(_this.getReferenceUnsafeStaticCast()); } Zone* zone = player->getZone(); if (zone == NULL) return; //controlledObject->insertToZone(player->getZone()); zone->transferObject(controlledObject, -1, true); Reference<VehicleDecayTask*> decayTask = new VehicleDecayTask(controlledObject); decayTask->execute(); if (vehicle != NULL && controlledObject->getServerObjectCRC() == 0x32F87A54) // Jetpack { controlledObject->setCustomizationVariable("/private/index_hover_height", 40, true); // Illusion of flying. player->executeObjectControllerAction(STRING_HASHCODE("mount"), controlledObject->getObjectID(), ""); // Auto mount. } updateStatus(1); if (vehicleControlObserver != NULL) player->dropObserver(ObserverEventType::STARTCOMBAT, vehicleControlObserver); }
void ObjectVersionUpdateManager::setResidence(uint64 buildingID, bool isResidence){ ObjectDatabase* database = ObjectDatabaseManager::instance()->loadObjectDatabase("playerstructures", true); ObjectInputStream objectData(2000); bool res = isResidence; String className; ObjectOutputStream newResidenceValue; TypeInfo<bool>::toBinaryStream(&res, &newResidenceValue ); if(!database->getData(buildingID,&objectData)){ if ( Serializable::getVariable<String>(STRING_HASHCODE("_className"), &className, &objectData)){ if(className == "BuildingObject"){ if ( !Serializable::getVariable<bool>(STRING_HASHCODE("BuildingObject.isOwnerResidence"), &isResidence, &objectData)){ //info("setResidence() adding the variable",true); ObjectOutputStream* newVariableData = addVariable("BuildingObject.isOwnerResidence", &objectData, &newResidenceValue); database->putData(buildingID, newVariableData, NULL); } else { //info("setResidence() has variable and value = " + String::valueOf(isResidence) + " ... changing it",true); ObjectOutputStream* test = changeVariableData(STRING_HASHCODE("BuildingObject.isOwnerResidence"), &objectData, &newResidenceValue); test->reset(); database->putData(buildingID, test, NULL); } } } else { info("ERROR couldn't get object " + String::valueOf(buildingID),true); } } }
void ReconMissionObjectiveImplementation::activate() { MissionObjectiveImplementation::activate(); ManagedReference<MissionObject* > mission = this->mission.get(); if (mission == NULL) return; ManagedReference<ZoneServer*> zoneServer = Core::lookupObject<ZoneServer>("ZoneServer"); if (locationActiveArea == NULL) { locationActiveArea = ( zoneServer->createObject(STRING_HASHCODE("object/mission_recon_area.iff"), 1)).castTo<MissionReconActiveArea*>(); Locker locker(locationActiveArea); locationActiveArea->setMissionObjective(_this.getReferenceUnsafeStaticCast()); } if (!locationActiveArea->isInQuadTree()) { String planetName = mission->getStartPlanet(); Zone* zone = zoneServer->getZone(planetName); if (zone != nullptr) { Reference<MissionReconActiveArea* > area = locationActiveArea; Core::getTaskManager()->executeTask([zone, area, this, mission] () { Locker locker(area); area->initializePosition(mission->getStartPositionX(), 0, mission->getStartPositionY()); area->setRadius(32.f); if (zone != NULL) { zone->transferObject(area, -1, true); } else { error("Failed to insert recon location to zone."); abort(); return; } }, "ReconMissionObjectiveActivateLambda"); } } ManagedReference<WaypointObject*> waypoint = mission->getWaypointToMission(); Locker locker(waypoint); waypoint->setPlanetCRC(mission->getStartPlanetCRC()); waypoint->setPosition(mission->getStartPositionX(), 0, mission->getStartPositionY()); waypoint->setActive(true); mission->updateMissionLocation(); }
int StructureDeedImplementation::handleObjectMenuSelect(CreatureObject* player, byte selectedID) { if (selectedID == 20) { if (!isASubChildOf(player)) return 0; player->executeObjectControllerAction(STRING_HASHCODE("placestructuremode"), getObjectID(), ""); return 0; } return DeedImplementation::handleObjectMenuSelect(player, selectedID); }
int PetManagerImplementation::notifyDestruction(TangibleObject* destructor, AiAgent* destructedObject, int condition) { if (!destructedObject->isPet() || destructedObject->isDead() || destructedObject->isIncapacitated()) return 1; if (destructedObject->isMount() && destructedObject->hasRidingCreature()) { Reference<CreatureObject*> rider = destructedObject->getSlottedObject("rider").castTo<CreatureObject*>(); if (rider != NULL) { Locker locker(rider); rider->updateCooldownTimer("mount_dismount", 0); rider->executeObjectControllerAction(STRING_HASHCODE("dismount")); } } destructor->removeDefender(destructedObject); ManagedReference<PetControlDevice*> petControlDevice = destructedObject->getControlDevice().get().castTo<PetControlDevice*>(); if (!destructor->isKiller() && petControlDevice != NULL && petControlDevice->getPetType() == CREATUREPET) { destructedObject->setCurrentSpeed(0); destructedObject->setPosture(CreaturePosture::INCAPACITATED, true); destructedObject->updateLocomotion(); uint32 incapTime = calculateIncapacitationTimer(destructedObject, condition); Reference<Task*> oldTask = destructedObject->getPendingTask("incapacitationRecovery"); if (oldTask != NULL && oldTask->isScheduled()) { oldTask->cancel(); destructedObject->removePendingTask("incapacitationRecovery"); } bool store = false; if (incapTime > 240) { // store pet after 4 minutes of incap store = true; incapTime = 240; } Reference<Task*> task = new PetIncapacitationRecoverTask(destructedObject, store); destructedObject->addPendingTask("incapacitationRecovery", task, incapTime * 1000); } else { killPet(destructor, destructedObject); } return 0; }
void ChatManagerImplementation::loadMailDatabase() { info("Checking mail for expiration...", true); ObjectDatabase* playerMailDatabase = ObjectDatabaseManager::instance()->loadObjectDatabase("mail", true); if (playerMailDatabase == NULL) { error("Could not load the player mail database."); return; } int i = 0; try { ObjectDatabaseIterator iterator(playerMailDatabase); uint64 objectID; uint32 timeStamp, currentTime = System::getTime(); ObjectInputStream* objectData = new ObjectInputStream(2000); while (i < 25000 && iterator.getNextKeyAndValue(objectID, objectData)) { if (!Serializable::getVariable<uint32>(STRING_HASHCODE("PersistentMessage.timeStamp"), &timeStamp, objectData)) { objectData->clear(); continue; } if (currentTime - timeStamp > PM_LIFESPAN) { Reference<PersistentMessage*> mail = Core::getObjectBroker()->lookUp(objectID).castTo<PersistentMessage*>(); if (mail != NULL) { i++; ObjectManager::instance()->destroyObjectFromDatabase(objectID); } } objectData->clear(); } delete objectData; } catch (DatabaseException& e) { error("Database exception in ChatManager::loadMailDatabase(): " + e.getMessage()); } info("Deleted " + String::valueOf(i) + " mails due to expiration.", true); }
int SpawnAreaImplementation::notifyObserverEvent(unsigned int eventType, Observable* observable, ManagedObject* arg1, int64 arg2) { if (eventType != ObserverEventType::OBJECTREMOVEDFROMZONE) return 1; SceneObject* sceno = dynamic_cast<SceneObject*>(observable); if (sceno == NULL) return 1; Locker locker(_this.getReferenceUnsafeStaticCast()); uint32 lairTemplate = spawnTypes.remove(sceno->getObjectID()); if (lairTemplate != 0) { int currentSpawnCount = spawnCountByType.get(lairTemplate) - 1; if (currentSpawnCount < 1) spawnCountByType.remove(lairTemplate); else spawnCountByType.put(lairTemplate, currentSpawnCount); --totalSpawnCount; locker.release(); if (sceno->isLairObject()) { ManagedReference<ActiveArea*> area = (ServerCore::getZoneServer()->createObject(STRING_HASHCODE("object/active_area.iff"), 0)).castTo<ActiveArea*>(); Locker locker(area); area->setRadius(64); area->setNoSpawnArea(true); area->initializePosition(sceno->getPositionX(), sceno->getPositionZ(), sceno->getPositionY()); zone->transferObject(area, -1, true); Reference<Task*> task = new RemoveNoSpawnAreaTask(area); task->schedule(300000); } } return 1; }
int ThrowGrenadeMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) { if (!sceneObject->isTangibleObject() || !player->isPlayerCreature()) return 0; if (!sceneObject->isASubChildOf(player)) { return 0; } ManagedReference<WeaponObject*> weapon = cast<WeaponObject*>(sceneObject); if(weapon == NULL) return 1; if(selectedID == 20) { player->sendCommand(STRING_HASHCODE("throwgrenade"), String::valueOf(sceneObject->getObjectID()), player->getTargetID()); return 1; } return WeaponObjectMenuComponent::handleObjectMenuSelect(sceneObject, player, selectedID); }
SceneObject* CreatureManagerImplementation::spawnDynamicSpawn(unsigned int lairTemplate, int difficulty, float x, float z, float y, float size) { LairTemplate* lairTmpl = creatureTemplateManager->getLairTemplate(lairTemplate); if (lairTmpl == NULL || lairTmpl->getBuildingType() != LairTemplate::NONE) return NULL; Vector<String>* mobiles = lairTmpl->getWeightedMobiles(); if (mobiles->size() == 0) return NULL; ManagedReference<TheaterObject*> theater = zoneServer->createObject(STRING_HASHCODE("object/intangible/theater/base_theater.iff"), 0).castTo<TheaterObject*>(); if (theater == NULL) { error("error creating intangible theater"); return NULL; } Locker blocker(theater); theater->initializePosition(x, z, y); theater->setDespawnOnNoPlayersInRange(true); ManagedReference<DynamicSpawnObserver*> dynamicObserver = new DynamicSpawnObserver(); dynamicObserver->deploy(); dynamicObserver->setLairTemplate(lairTmpl); dynamicObserver->setDifficulty(difficulty); dynamicObserver->setObserverType(ObserverType::LAIR); dynamicObserver->setSize(size); theater->registerObserver(ObserverEventType::CREATUREDESPAWNED, dynamicObserver); theater->registerObserver(ObserverEventType::OBJECTREMOVEDFROMZONE, dynamicObserver); zone->transferObject(theater, -1, false); theater->createChildObjects(); dynamicObserver->spawnInitialMobiles(theater); return theater; }
void PlayerManagementSessionImplementation::getPlayerInfo(const int tablevel, const String& firstName) { ManagedReference<CreatureObject*> admin = this->admin.get(); if (admin == NULL) return; sendAccountInfo(); banMode = NONE; if (tablevel != 2) return; ManagedReference<CreatureObject*> targetPlayer = NULL; if (!firstName.isEmpty()) targetPlayer = playerManager->getPlayer(firstName); if (targetPlayer == NULL) { return; } admin->sendCommand(STRING_HASHCODE("server"), "playerinfo " + firstName); }
void EntertainerMissionObjectiveImplementation::activate() { Locker _lock(_this.getReferenceUnsafeStaticCast()); ManagedReference<MissionObject* > mission = this->mission.get(); MissionObjectiveImplementation::activate(); if (hasObservers()) { return; } if (mission == NULL) return; ManagedReference<ZoneServer*> zoneServer = Core::lookupObject<ZoneServer>("ZoneServer"); if (locationActiveArea == NULL) { locationActiveArea = ( zoneServer->createObject(STRING_HASHCODE("object/active_area.iff"), 1)).castTo<ActiveArea*>(); } if (!locationActiveArea->isInQuadTree()) { String planetName = mission->getStartPlanet(); Zone* zone = zoneServer->getZone(planetName); Locker locker(locationActiveArea); locationActiveArea->initializePosition(mission->getStartPositionX(), 0, mission->getStartPositionY()); locationActiveArea->setRadius(32.f); if (zone != NULL) { zone->transferObject(locationActiveArea, -1, true); } else { error("Failed to insert entertainer location to zone."); abort(); return; } } Locker locationLocker(locationActiveArea); ManagedReference<MissionObserver*> observer1 = new MissionObserver(_this.getReferenceUnsafeStaticCast()); addObserver(observer1, true); locationActiveArea->registerObserver(ObserverEventType::ENTEREDAREA, observer1); ManagedReference<MissionObserver*> observer2 = new MissionObserver(_this.getReferenceUnsafeStaticCast()); addObserver(observer2, true); locationActiveArea->registerObserver(ObserverEventType::EXITEDAREA, observer2); locationLocker.release(); WaypointObject* waypoint = mission->getWaypointToMission(); if (waypoint == NULL) { Locker mlocker(mission); waypoint = mission->createWaypoint(); } Locker wplocker(waypoint); waypoint->setPlanetCRC(mission->getStartPlanetCRC()); waypoint->setPosition(mission->getStartPositionX(), 0, mission->getStartPositionY()); waypoint->setActive(true); mission->updateMissionLocation(); }
void PlanetManagerImplementation::loadClientRegions() { TemplateManager* templateManager = TemplateManager::instance(); IffStream* iffStream = templateManager->openIffFile("datatables/clientregion/" + zone->getZoneName() + ".iff"); Reference<PlanetMapCategory*> cityCat = TemplateManager::instance()->getPlanetMapCategoryByName("city"); if (iffStream == NULL) { info("No client regions found."); return; } DataTableIff dtiff; dtiff.readObject(iffStream); for (int i = 0; i < dtiff.getTotalRows(); ++i) { String regionName; float x, y, radius; DataTableRow* row = dtiff.getRow(i); row->getValue(0, regionName); row->getValue(1, x); row->getValue(2, y); row->getValue(3, radius); ManagedReference<CityRegion*> cityRegion = regionMap.getRegion(regionName); if (cityRegion == NULL) { cityRegion = new CityRegion(); Locker locker(cityRegion); cityRegion->deploy(); cityRegion->setRegionName(regionName); cityRegion->setZone(zone); regionMap.addRegion(cityRegion); } Locker locker(cityRegion); ManagedReference<Region*> region = cityRegion->addRegion(x, y, radius, false); locker.release(); if (region != NULL) { Locker rlocker(region); if (cityRegion->getRegionsCount() == 1) {//Register the first region only. region->setPlanetMapCategory(cityCat); zone->registerObjectWithPlanetaryMap(region); } region->setMunicipalZone(true); ManagedReference<SceneObject*> scenery = NULL; if (gcwManager != NULL) { int strongholdFaction = gcwManager->isStrongholdCity(regionName); if (strongholdFaction == GCWManager::IMPERIALHASH || regionName.contains("imperial")) { scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/particle/particle_distant_ships_imperial.iff"), 0); } else if (strongholdFaction == GCWManager::REBELHASH || regionName.contains("rebel")) { scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/particle/particle_distant_ships_rebel.iff"), 0); } else { scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/particle/particle_distant_ships.iff"), 0); } } else { scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/particle/particle_distant_ships.iff"), 0); } Locker slocker(scenery, region); scenery->initializePosition(x, zone->getHeight(x, y) + 100, y); region->attachScenery(scenery); } ManagedReference<ActiveArea*> noBuild = zone->getZoneServer()->createObject(STRING_HASHCODE("object/active_area.iff"), 0).castTo<ActiveArea*>(); Locker areaLocker(noBuild); noBuild->initializePosition(x, 0, y); ManagedReference<CircularAreaShape*> areaShape = new CircularAreaShape(); Locker shapeLocker(areaShape); areaShape->setRadius(radius * 2); areaShape->setAreaCenter(x, y); noBuild->setAreaShape(areaShape); noBuild->setRadius(radius * 2); noBuild->setNoBuildArea(true); // Cities already have "Municipal" protection so the structure no-build should not apply to camps noBuild->setCampingPermitted(true); Locker zoneLocker(zone); zone->transferObject(noBuild, -1, true); } info("Added " + String::valueOf(regionMap.getTotalRegions()) + " client regions."); delete iffStream; }
void PlanetManagerImplementation::initialize() { performanceLocations = new MissionTargetMap(); numberOfCities = 0; info("Loading planet."); planetTravelPointList->setZoneName(zone->getZoneName()); loadClientRegions(); loadClientPoiData(); loadLuaConfig(); loadTravelFares(); if (zone->getZoneName() == "dathomir") { Reference<ActiveArea*> area = zone->getZoneServer()->createObject(STRING_HASHCODE("object/fs_village_area.iff"), 0).castTo<ActiveArea*>(); Locker locker(area); area->setRadius(768.f); area->initializePosition(5306, 0, -4145); zone->transferObject(area, -1, true); ManagedReference<SceneObject*> scenery = zone->getZoneServer()->createObject(STRING_HASHCODE("object/static/structure/general/fs_village_nobuild_768m.iff"), 0); Locker slocker(scenery, area); scenery->initializePosition(5306, zone->getHeight(5306, -4145), -4145); area->attachScenery(scenery); slocker.release(); locker.release(); Reference<ActiveArea*> sarlaccArea = zone->getZoneServer()->createObject(STRING_HASHCODE("object/sarlacc_area.iff"), 0).castTo<ActiveArea*>(); Locker locker2(sarlaccArea); sarlaccArea->setRadius(60.f); sarlaccArea->initializePosition(-2085, 0, 3147); zone->transferObject(sarlaccArea, -1, true); locker2.release(); Reference<ActiveArea*> sarlaccPreArea = zone->getZoneServer()->createObject(STRING_HASHCODE("object/sarlacc_area.iff"), 0).castTo<ActiveArea*>(); Locker locker3(sarlaccPreArea); sarlaccPreArea->setRadius(30.f); sarlaccPreArea->initializePosition(-2085, 0, 3147); zone->transferObject(sarlaccPreArea, -1, true); } if (zone->getZoneName() == "tatooine") { Reference<ActiveArea*> area = zone->getZoneServer()->createObject(STRING_HASHCODE("object/sarlacc_area.iff"), 0).castTo<ActiveArea*>(); Locker locker(area); area->setRadius(30.f); area->initializePosition(-6174, 0, -3361); zone->transferObject(area, -1, true); locker.release(); Reference<ActiveArea*> preArea = zone->getZoneServer()->createObject(STRING_HASHCODE("object/sarlacc_area.iff"), 0).castTo<ActiveArea*>(); Locker locker2(preArea); preArea->setRadius(60.f); preArea->initializePosition(-6174, 0, -3361); zone->transferObject(preArea, -1, true); } }
void EntertainingSessionImplementation::activateEntertainerBuff(CreatureObject* creature, int performanceType) { ManagedReference<CreatureObject*> entertainer = this->entertainer.get(); try { //Check if on Deny Service list if(isInDenyServiceList(creature)) { 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() != creature->getGroupID()) && entPlayer->getPerformanceBuffTarget() != creature->getObjectID()) { return; } if(!canGiveEntertainBuff()) return; // Returns the Number of Minutes for the Buff Duration float buffDuration = getEntertainerBuffDuration(creature, performanceType); if (buffDuration * 60 < 10.0f) { //10 sec minimum buff duration return; } //1 minute minimum listen/watch time int timeElapsed = time(0) - getEntertainerBuffStartTime(creature, performanceType); if(timeElapsed < 60) { creature->sendSystemMessage("You must listen or watch a performer for at least 1 minute in order to gain the entertainer buffs."); return; } // Returns a % of base stat int campModTemp = 100; float buffStrength = getEntertainerBuffStrength(creature, performanceType) / 100.0f; if(buffStrength == 0) return; ManagedReference<PerformanceBuff*> oldBuff = NULL; switch (performanceType){ case PerformanceType::MUSIC: { uint32 focusBuffCRC = STRING_HASHCODE("performance_enhance_music_focus"); uint32 willBuffCRC = STRING_HASHCODE("performance_enhance_music_willpower"); oldBuff = cast<PerformanceBuff*>(creature->getBuff(focusBuffCRC)); if (oldBuff != NULL && oldBuff->getBuffStrength() > buffStrength) return; ManagedReference<PerformanceBuff*> focusBuff = new PerformanceBuff(creature, focusBuffCRC, buffStrength, buffDuration * 60, PerformanceBuffType::MUSIC_FOCUS); ManagedReference<PerformanceBuff*> willBuff = new PerformanceBuff(creature, willBuffCRC, buffStrength, buffDuration * 60, PerformanceBuffType::MUSIC_WILLPOWER); Locker locker(focusBuff); creature->addBuff(focusBuff); locker.release(); Locker locker2(willBuff); creature->addBuff(willBuff); break; } case PerformanceType::DANCE: { uint32 mindBuffCRC = STRING_HASHCODE("performance_enhance_dance_mind"); oldBuff = cast<PerformanceBuff*>(creature->getBuff(mindBuffCRC)); if (oldBuff != NULL && oldBuff->getBuffStrength() > buffStrength) return; ManagedReference<PerformanceBuff*> mindBuff = new PerformanceBuff(creature, mindBuffCRC, buffStrength, buffDuration * 60, PerformanceBuffType::DANCE_MIND); Locker locker(mindBuff); creature->addBuff(mindBuff); break; } } } catch(Exception& e) { } }
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"); }
int CoaEncodedDiskMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) { if (!player->isPlayerCreature()) { return 0; } SceneObject* inventory = player->getSlottedObject("inventory"); if (inventory == NULL) { return 0; } if (!inventory->hasObjectInContainer(sceneObject->getObjectID())) { player->sendSystemMessage("@encoded_disk/message_fragment:sys_not_in_inv"); // The disk can't be used unless it is in your inventory! return 0; } TangibleObject* disk = cast<TangibleObject*>(sceneObject); if (disk == NULL) { return 0; } PlayerObject* ghost = player->getPlayerObject(); if (ghost == NULL) { return 0; } String faction = getFaction(disk); if (faction.isEmpty()) { return 0; } bool decoded = isDecoded(disk); if (selectedID == 20) { String file = "@theme_park/alderaan/act2/" + faction + "_missions"; String title, body; if (faction == "imperial") { title = file + ":disk_title"; body = file + ":disk_text"; } else if (faction == "rebel" && decoded) { title = file + ":disk_decoded_title"; body = file + ":disk_decoded_text"; } else { title = file + ":disk_encoded_title"; body = file + ":disk_encoded_text"; } ManagedReference<SuiMessageBox*> box = new SuiMessageBox(player, 0); box->setPromptTitle(title); box->setPromptText(body); box->setUsingObject(disk); box->setOkButton(true, "@theme_park/alderaan/act2/shared_" + faction + "_missions:close"); // Close ghost->addSuiBox(box); player->sendMessage(box->generateMessage()); return 0; } else if (selectedID == 68) { if (faction != "rebel") { return 0; } String file = "@theme_park/alderaan/act2/shared_" + faction + "_missions"; uint32 decoderCRC = STRING_HASHCODE("object/tangible/encoded_disk/dead_eye_decoder.iff"); bool hasDecoder = false; for (int i=0; i< inventory->getContainerObjectsSize(); i++) { SceneObject* sco = inventory->getContainerObject(i); if (sco->getServerObjectCRC() == decoderCRC) { hasDecoder = true; break; } } if (hasDecoder) { String key = "disk_name_decoded"; StringId stringid("theme_park/alderaan/act2/shared_rebel_missions", key); Locker locker(disk); disk->setObjectName(stringid, true); player->sendSystemMessage(file + ":decoded_data_disk"); // Using the old Imperial Decoder you were able to decode the Dead Eye message. return 0; } else { player->sendSystemMessage(file + ":decode_failed"); // You do not have the required decoder to decode this message. return 0; } } return TangibleObjectMenuComponent::handleObjectMenuSelect(sceneObject, player, selectedID); }