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