void PtexReader::PackedFace::reduce(FaceData*& face, PtexReader* r,
Res newres, PtexUtils::ReduceFn reducefn)
{
// get reduce lock and make sure we still need to reduce
AutoMutex rlocker(r->reducelock);
if (face) {
// another thread must have generated it while we were waiting
AutoLockCache clocker(_cache->cachelock);
// make sure it's still there now that we have the lock
if (face) {
face->ref();
return;
}
}
// allocate a new face and reduce image
DataType dt = r->datatype();
int nchan = r->nchannels();
PackedFace* pf = new PackedFace((void**)&face, _cache, newres,
_pixelsize, _pixelsize * newres.size());
// reduce and copy into new face
reducefn(_data, _pixelsize * _res.u(), _res.u(), _res.v(),
pf->_data, _pixelsize * newres.u(), dt, nchan);
AutoLockCache clocker(_cache->cachelock);
face = pf;
// clean up unused data
_cache->purgeData();
}
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 CreatureManagerImplementation::sample(Creature* creature, CreatureObject* player) {
Zone* zone = creature->getZone();
if (zone == NULL || !creature->isCreature() || creature->isNonPlayerCreatureObject()) {
return;
}
if (!creature->canCollectDna(player)){
player->sendSystemMessage("@bio_engineer:harvest_dna_cant_harvest");
return;
}
if (player->isRidingMount()) {
player->sendSystemMessage("You cannot sample DNA while mounted");
return;
}
if(player->getPendingTask("sampledna") != NULL) {
player->sendSystemMessage("@bio_engineer:harvest_dna_already_harvesting");
return;
}
if (!creature->hasSkillToSampleMe(player)){
player->sendSystemMessage("@bio_engineer:harvest_dna_skill_too_low");
return;
}
Locker clocker(creature);
ManagedReference<SampleDnaTask*> task = new SampleDnaTask(creature, player);
player->addPendingTask("sampledna",task,0);
}
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 EntertainingSessionImplementation::healWounds(CreatureObject* creature, float woundHeal, float shockHeal) {
float amountHealed = 0;
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
Locker clocker(creature, entertainer);
if(!canGiveEntertainBuff())
return;
if(isInDenyServiceList(creature))
return;
if(shockHeal > 0 && creature->getShockWounds() > 0 && canHealBattleFatigue()) {
creature->addShockWounds(-shockHeal, true, false);
amountHealed += shockHeal;
}
if(woundHeal > 0 && (creature->getWounds(CreatureAttribute::MIND) > 0
|| creature->getWounds(CreatureAttribute::FOCUS) > 0
|| creature->getWounds(CreatureAttribute::WILLPOWER) > 0)) {
creature->healWound(entertainer, CreatureAttribute::MIND, woundHeal, true, false);
creature->healWound(entertainer, CreatureAttribute::FOCUS, woundHeal, true, false);
creature->healWound(entertainer, CreatureAttribute::WILLPOWER, woundHeal, true, false);
amountHealed += woundHeal;
}
clocker.release();
if(entertainer->getGroup() != NULL)
addHealingXpGroup(amountHealed);
else
addHealingXp(amountHealed);
}
void EntertainingSessionImplementation::addHealingXpGroup(int xp) {
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
ManagedReference<GroupObject*> group = entertainer->getGroup();
int groupSize = group->getGroupSize();
ManagedReference<PlayerManager*> playerManager = entertainer->getZoneServer()->getPlayerManager();
for(int i = 0; i < groupSize; ++i) {
ManagedReference<CreatureObject*> groupMember = group->getGroupMember(i)->isPlayerCreature() ? group->getGroupMember(i).castTo<CreatureObject*>() : NULL;
if (groupMember != NULL) {
Locker clocker(groupMember, entertainer);
if (groupMember->isEntertaining() && groupMember->isInRange(entertainer, 40.0f)
&& groupMember->hasSkill("social_entertainer_novice")) {
String healxptype("entertainer_healing");
if (playerManager != NULL)
playerManager->awardExperience(groupMember, healxptype, xp, true);
}
}
}
}
void JukeboxImplementation::setRadius(float newRadius) {
ManagedReference<Jukebox*> jbox = _this.getReferenceUnsafeStaticCast();
SortedVector<ManagedReference<SceneObject*> >* children = jbox->getChildObjects();
if (newRadius == radius)
return;
if (children == NULL)
return;
radius = newRadius;
for (int i = 0; i < children->size(); ++i) {
ManagedReference<SceneObject*> child = children->get(i);
if (child != NULL && child->isActiveArea()) {
ManagedReference<ActiveArea*> area = cast<ActiveArea*>(child.get());
Locker clocker(area, jbox);
area->setRadius(newRadius);
return;
}
}
}
void EntertainingSessionImplementation::startPlayingMusic(const String& song, const String& instrumentAnimation, int instrid) {
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
Locker locker(entertainer);
ManagedReference<GroupObject*> group = entertainer->getGroup();
if (group != NULL) {
if (group->getBandSong() != song) {
Locker clocker(group, entertainer);
group->setBandSong(song);
}
}
sendEntertainingUpdate(entertainer, 0.0125, instrumentAnimation, 0x07352BAC, instrid);
performanceName = song;
playingMusic = true;
entertainer->sendSystemMessage("@performance:music_start_self");
entertainer->setListenToID(entertainer->getObjectID(), true);
externalInstrument = getInstrument(entertainer);
if (externalInstrument != NULL)
externalInstrument->setBeingUsed(true);
updateEntertainerMissionStatus(true, MissionObject::MUSICIAN);
entertainer->notifyObservers(ObserverEventType::STARTENTERTAIN, entertainer);
startEntertaining();
}
void LootkitObjectImplementation::createItem() {
for (int i = 0; i<comps.size(); ++i) {
if (components.get(comps.get(i)) == 0) {
return; // Still missing pieces
}
}
ManagedReference<CreatureObject*> player = getPlayer();
if (player != NULL) {
player->sendSystemMessage("@loot_kit:new_item_created");
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
ZoneServer* zoneServer = server->getZoneServer();
ManagedReference<SceneObject*> rewardObject = zoneServer->createObject(reward.get(System::random(reward.size()-1)), 2);
Locker clocker(inventory, player);
rewardObject->sendTo(player, true);
if (inventory->transferObject(rewardObject, -1, true)) {
//getParent()->removeObject(_this, true);
destroyObjectFromWorld(true);
if (isPersistent())
destroyObjectFromDatabase(true);
}
}
}
void CityHallZoneComponent::destroyObjectFromWorld(SceneObject* sceneObject, bool sendSelfDestroy) const {
ZoneServer* zoneServer = sceneObject->getZoneServer();
if (zoneServer == NULL || zoneServer->isServerShuttingDown()) {
ZoneComponent::destroyObjectFromWorld(sceneObject, sendSelfDestroy);
return;
}
ManagedReference<CityRegion*> cityRegion = sceneObject->getCityRegion().get();
if (cityRegion != NULL ) {
Locker clocker(cityRegion, sceneObject);
if (cityRegion->getCityHall() == sceneObject) {
cityRegion->setCityHall(NULL);
}
clocker.release();
CityManager* cityManager = zoneServer->getCityManager();
cityManager->destroyCity(cityRegion);
}
ZoneComponent::destroyObjectFromWorld(sceneObject, sendSelfDestroy);
}
Region* CityRegionImplementation::addRegion(float x, float y, float radius, bool persistent) {
if (zone == NULL) {
return NULL;
}
static const String temp = "object/region_area.iff";
ManagedReference<SceneObject*> obj = zone->getZoneServer()->createObject(temp.hashCode(), persistent ? 1 : 0);
if (obj == NULL || !obj->isRegion()) {
return NULL;
}
Locker clocker(obj, _this.getReferenceUnsafeStaticCast());
ManagedReference<Region*> region = cast<Region*>(obj.get());
region->setCityRegion(_this.getReferenceUnsafeStaticCast());
region->setRadius(radius);
region->initializePosition(x, 0, y);
region->setObjectName(regionName, false);
if (isClientRegion())
region->setNoBuildArea(true);
zone->transferObject(region, -1, false);
regions.put(region);
return region;
}
void ImageDesignSessionImplementation::cancelImageDesign(uint64 designer, uint64 targetPlayer, uint64 tent, int type, const ImageDesignData& data) {
ManagedReference<CreatureObject*> designerCreature = this->designerCreature.get();
ManagedReference<CreatureObject*> targetCreature = this->targetCreature.get();
if (targetCreature == NULL || designerCreature == NULL)
return;
Locker locker(designerCreature);
Locker clocker(targetCreature, designerCreature);
imageDesignData = data;
ImageDesignRejectMessage* message = new ImageDesignRejectMessage(targetCreature->getObjectID(), designer, targetPlayer,tent, type);
imageDesignData.insertToMessage(message);
targetCreature->sendMessage(message);
ImageDesignRejectMessage* msg2 = new ImageDesignRejectMessage(designerCreature->getObjectID(), designer, targetPlayer,tent, type);
imageDesignData.insertToMessage(msg2);
designerCreature->sendMessage(msg2);
//TODO: Needs research.
cancelSession();
}
void ImageDesignSessionImplementation::sessionTimeout() {
ManagedReference<CreatureObject*> designerCreature = this->designerCreature.get();
ManagedReference<CreatureObject*> targetCreature = this->targetCreature.get();
if (designerCreature != NULL) {
Locker locker(designerCreature);
if (designerCreature->getParentRecursively(SceneObjectType::SALONBUILDING) == NULL || imageDesignData.isAcceptedByDesigner()) {
designerCreature->sendSystemMessage("Image Design session has timed out. Changes aborted.");
cancelImageDesign(designerCreature->getObjectID(), targetCreature->getObjectID(), 0, 0, imageDesignData);
return;
}
}
if (targetCreature != NULL) {
Locker locker(designerCreature);
Locker clocker(targetCreature, designerCreature);
if (targetCreature->getParentRecursively(SceneObjectType::SALONBUILDING) == NULL || imageDesignData.isAcceptedByDesigner()) {
targetCreature->sendSystemMessage("Image Design session has timed out. Changes aborted.");
cancelImageDesign(designerCreature->getObjectID(), targetCreature->getObjectID(), 0, 0, imageDesignData);
return;
}
}
}
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);
}
void ShipControlDeviceImplementation::generateObject(CreatureObject* player) {
//info("generating ship", true);
//return;
ZoneServer* zoneServer = getZoneServer();
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
Locker clocker(controlledObject, player);
controlledObject->initializePosition(player->getPositionX(), player->getPositionZ() + 10, player->getPositionY());
player->getZone()->transferObject(controlledObject, -1, true);
//controlledObject->insertToZone(player->getZone());
//removeObject(controlledObject, true);
controlledObject->transferObject(player, 5, true);
player->setState(CreatureState::PILOTINGSHIP);
//controlledObject->inflictDamage(player, 0, System::random(50), true);
updateStatus(1);
PlayerObject* ghost = player->getPlayerObject();
if (ghost != NULL)
ghost->setTeleporting(true);
}
void DnaManager::generationalSample(PetDeed* deed, CreatureObject* player,int quality) {
// We are making a generational sample rules are a little different.
// Reduce each stat by lets say 10% as the max to be on par with old docs
int cl = deed->getLevel();
int ferocity = 0;
int factor = (int)System::random(quality) - 7;
int reductionAmount = (factor + 15 + quality) ;
int cle = reduceByPercent(deed->getCleverness(),reductionAmount);
int cou = reduceByPercent(deed->getCourage(),reductionAmount);
int dep = reduceByPercent(deed->getDependency(),reductionAmount);
int dex = reduceByPercent(deed->getDexterity(),reductionAmount);
int end = reduceByPercent(deed->getEndurance(),reductionAmount);
int fie = reduceByPercent(deed->getFierceness(),reductionAmount);
int frt = reduceByPercent(deed->getFortitude(),reductionAmount);
int har = reduceByPercent(deed->getHardiness(),reductionAmount);
int ite = reduceByPercent(deed->getIntelligence(),reductionAmount);
int pow = reduceByPercent(deed->getPower(),reductionAmount);
// calculate rest of stats here
ManagedReference<DnaComponent*> prototype = player->getZoneServer()->createObject(qualityTemplates.get(quality), 1).castTo<DnaComponent*>();
if (prototype == NULL) {
return;
}
Locker clocker(prototype);
// Check Here for unique npcs
prototype->setSource(deed->getTemplateName());
prototype->setQuality(quality);
prototype->setLevel(cl);
String serial = player->getZoneServer()->getCraftingManager()->generateSerial();
prototype->setSerialNumber(serial);
prototype->setStats(cle,end,fie,pow,ite,cou,dep,dex,frt,har);
prototype->setStun(deed->getStun());
prototype->setKinetic(deed->getKinetic());
prototype->setEnergy(deed->getEnergy());
prototype->setBlast(deed->getBlast());
prototype->setHeat(deed->getHeat());
prototype->setCold(deed->getCold());
prototype->setElectric(deed->getElectric());
prototype->setAcid(deed->getAcid());
prototype->setSaber(deed->getSaber());
prototype->setRanged(deed->getRanged());
prototype->setArmorRating(deed->getArmor());
prototype->setSpecialAttackOne(deed->getSpecial1());
prototype->setSpecialAttackTwo(deed->getSpecial2());
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
if (inventory->hasFullContainerObjects()) {
StringIdChatParameter err("survey", "no_inv_space");
player->sendSystemMessage(err);
player->setPosture(CreaturePosture::UPRIGHT, true);
return;
}
Locker locker(inventory);
inventory->transferObject(prototype, -1, true,false);
inventory->broadcastObject(prototype, true);
}
Reference<SceneObject*> PlanetManagerImplementation::loadSnapshotObject(WorldSnapshotNode* node, WorldSnapshotIff* wsiff, int& totalObjects) {
uint64 objectID = node->getObjectID();
String templateName = wsiff->getObjectTemplateName(node->getNameID());
ZoneServer* zoneServer = server->getZoneServer();
Reference<SceneObject*> object = zoneServer->getObject(objectID);
++totalObjects;
if (ConfigManager::instance()->isProgressMonitorActivated())
printf("\r\tLoading snapshot objects: [%d] / [?]\t", totalObjects);
//Object already exists, exit.
if (object != NULL)
return NULL;
Reference<SceneObject*> parentObject = zoneServer->getObject(node->getParentID());
String serverTemplate = templateName.replaceFirst("shared_", "");
Vector3 position = node->getPosition();
object = zoneServer->createClientObject(serverTemplate.hashCode(), objectID);
object->initializePosition(position.getX(), position.getZ(), position.getY());
object->setDirection(node->getDirection());
if (parentObject != NULL && parentObject->isBuildingObject() && object->isCellObject()) {
CellObject* cell = cast<CellObject*>(object.get());
BuildingObject* building = cast<BuildingObject*>(parentObject.get());
building->addCell(cell, node->getCellID());
}
if (parentObject != NULL)
parentObject->transferObject(object, -1);
else if (node->getParentID() != 0)
error("parent id " + String::valueOf(node->getParentID()));
if (parentObject == NULL) {
//object->insertToZone(zone);
Locker clocker(object);
zone->transferObject(object, -1, true);
}
//Load child nodes
for (int i = 0; i < node->getNodeCount(); ++i) {
WorldSnapshotNode* childNode = node->getNode(i);
if (childNode == NULL)
continue;
loadSnapshotObject(childNode, wsiff, totalObjects);
}
//object->createChildObjects();
return object;
}
int PowerRegulatorMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) const {
if (player->isDead() || player->isIncapacitated() || selectedID != 20)
return 1;
ManagedReference<BuildingObject*> building = sceneObject->getParentRecursively(SceneObjectType::FACTIONBUILDING).castTo<BuildingObject*>();
ManagedReference<TangibleObject*> powerRegulator = cast<TangibleObject*>(sceneObject);
if (building == NULL)
return 1;
Zone* zone = building->getZone();
if (zone == NULL)
return 1;
GCWManager* gcwMan = zone->getGCWManager();
if (gcwMan == NULL)
return 1;
if (!gcwMan->isBaseVulnerable(building))
return 1;
if (!gcwMan->areOpposingFactions(player->getFaction(), building->getFaction())) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:no_tamper"); // You are not an enemy of this structure. Why would you want to tamper?
return 1;
} else if (gcwMan->isPowerOverloaded(building)) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:already_overloading"); // The power regulator has already been set to overload.
return 1;
} else if (!gcwMan->isDNASampled(building)) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:other_objectives"); // Other objectives must be disabled prior to gaining access to this one.
return 1;
} else if (player->isInCombat()) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:power_not_in_combat"); // You cannot align the power flow to overload if you are in combat!
return 1;
} else if (powerRegulator->getParentID() != player->getParentID()) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:power_not_in_room"); // You cannot align the power flow if you are not even in the same room!
return 1;
} else if (powerRegulator->getDistanceTo(player) > 15) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:power_too_far"); // You are too far away from the power regulator to continue the setup!
return 1;
} else if (!player->hasSkill("combat_commando_heavyweapon_speed_02")) {
player->sendSystemMessage("@faction/faction_hq/faction_hq_response:commando_only"); // Only an experienced commando with heavy weapons training could expect to rig the regulators for overload
return 1;
}
Reference<CreatureObject*> playerRef = player;
Core::getTaskManager()->executeTask([=] () {
Locker locker(playerRef);
Locker clocker(building, playerRef);
gcwMan->sendPowerRegulatorControls(playerRef, building, powerRegulator);
}, "SendPowerRegulatorControlsLambda");
return 0;
}
void 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 SlicingSessionImplementation::handleSlice(SuiListBox* suiBox) {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (player == NULL || tangibleObject == NULL)
return;
Locker locker(player);
Locker clocker(tangibleObject, player);
PlayerManager* playerManager = player->getZoneServer()->getPlayerManager();
suiBox->removeAllMenuItems();
suiBox->setCancelButton(false,"@cancel");
StringBuffer prompt;
prompt << "@slicing/slicing:";
prompt << getPrefix(tangibleObject) + "examine";
suiBox->setPromptText(prompt.toString());
player->getPlayerObject()->addSuiBox(suiBox);
player->sendMessage(suiBox->generateMessage());
if (tangibleObject->isContainerObject() || tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE) {
handleContainerSlice();
playerManager->awardExperience(player, "slicing", 125, true); // Container Slice XP
} else if (tangibleObject->isMissionTerminal()) {
MissionTerminal* term = cast<MissionTerminal*>( tangibleObject.get());
playerManager->awardExperience(player, "slicing", 250, true); // Terminal Slice XP
term->addSlicer(player);
player->sendSystemMessage("@slicing/slicing:terminal_success");
} else if (tangibleObject->isWeaponObject()) {
handleWeaponSlice();
playerManager->awardExperience(player, "slicing", 500, true); // Weapon Slice XP
} else if (tangibleObject->isArmorObject()) {
handleArmorSlice();
playerManager->awardExperience(player, "slicing", 1000, true); // Armor Slice XP
} else if ( isBaseSlice()){
playerManager->awardExperience(player,"slicing", 1000, true); // Base slicing
Zone* zone = player->getZone();
if(zone != NULL){
GCWManager* gcwMan = zone->getGCWManager();
if(gcwMan != NULL){
SecuritySliceTask* task = new SecuritySliceTask(gcwMan, tangibleObject.get(), player);
task->execute();
}
}
}
endSlicing();
}
void EntertainingSessionImplementation::stopDancing() {
ManagedReference<CreatureObject*> entertainer = this->entertainer.get();
if (entertainer == NULL)
return;
Locker locker(entertainer);
if (!dancing)
return;
dancing = false;
entertainer->sendSystemMessage("@performance:dance_stop_self");
performanceName = "";
sendEntertainingUpdate(entertainer, 0.8025000095f, entertainer->getPerformanceAnimation(), 0, 0);
if (entertainer->getPosture() == CreaturePosture::SKILLANIMATING)
entertainer->setPosture(CreaturePosture::UPRIGHT);
ManagedReference<PlayerManager*> playerManager = entertainer->getZoneServer()->getPlayerManager();
while (watchers.size() > 0) {
ManagedReference<CreatureObject*> watcher = watchers.elementAt(0).getKey();
Locker clocker(watcher, entertainer);
playerManager->stopWatch(watcher, entertainer->getObjectID(), true, true, false);
if (!watcher->isWatching())
sendEntertainmentUpdate(watcher, 0, "", true);
watchers.drop(watcher);
}
if (tickTask != NULL && tickTask->isScheduled())
tickTask->cancel();
updateEntertainerMissionStatus(false, MissionObject::DANCER);
entertainer->notifyObservers(ObserverEventType::STOPENTERTAIN, entertainer);
entertainer->dropObserver(ObserverEventType::POSTURECHANGED, observer);
if (!dancing && !playingMusic) {
ManagedReference<PlayerObject*> entPlayer = entertainer->getPlayerObject();
if (entPlayer != NULL && entPlayer->getPerformanceBuffTarget() != 0)
entPlayer->setPerformanceBuffTarget(0);
entertainer->dropActiveSession(SessionFacadeType::ENTERTAINING);
}
}
void MissionObjectiveImplementation::destroyObjectFromDatabase() {
for (int i = 0; i < observers.size(); ++i) {
MissionObserver* observer = observers.get(i);
Locker clocker(observer, _this.getReferenceUnsafeStaticCast());
observer->destroyObjectFromDatabase();
}
ObjectManager::instance()->destroyObjectFromDatabase(_this.getReferenceUnsafeStaticCast()->_getObjectID());
}
void SlicingSessionImplementation::handleSliceFailed() {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (tangibleObject == NULL || player == NULL)
return;
if (tangibleObject->isMissionTerminal())
player->sendSystemMessage("@slicing/slicing:terminal_fail");
else if (tangibleObject->isWeaponObject())
player->sendSystemMessage("@slicing/slicing:fail_weapon");
else if (tangibleObject->isArmorObject())
player->sendSystemMessage("@slicing/slicing:fail_armor");
else if (tangibleObject->isContainerObject() || tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE)
player->sendSystemMessage("@slicing/slicing:container_fail");
else if (isBaseSlice())
player->sendSystemMessage("@slicing/slicing:hq_security_fail"); // Unable to sucessfully slice the terminal, you realize that the only away
else
player->sendSystemMessage("Your attempt to slice the object has failed.");
if (tangibleObject->isContainerObject()) {
ManagedReference<Container*> container = tangibleObject.castTo<Container*>();
Locker clocker(container, player);
if(!container)
return;
container->setSliced(true);
if(!container->isRelocking())
{
relockEvent = new RelockLootContainerEvent(container);
relockEvent->schedule(container->getLockTime()); // This will reactivate the 'broken' lock. (1 Hour)
}
} else if (isBaseSlice()){
Zone* zone = player->getZone();
if(zone != NULL){
GCWManager* gcwMan = zone->getGCWManager();
if(gcwMan != NULL)
gcwMan->failSecuritySlice(tangibleObject.get());
}
} else if (!tangibleObject->isMissionTerminal()) {
tangibleObject->setSliced(true);
}
endSlicing();
}
void GroupManager::leaveGroup(ManagedReference<GroupObject*> group, CreatureObject* player) {
// Pre: player locked
// Post: player locked
if (group == NULL)
return;
try {
Locker clocker(group, player);
ChatRoom* groupChannel = group->getGroupChannel();
if (groupChannel != NULL && player->isPlayerCreature()) {
CreatureObject* playerCreature = cast<CreatureObject*>( player);
groupChannel->removePlayer(playerCreature, false);
groupChannel->sendDestroyTo(playerCreature);
ChatRoom* room = groupChannel->getParent();
room->sendDestroyTo(playerCreature);
}
if (!group->isOtherMemberPlayingMusic(player))
group->setBandSong("");
player->updateGroup(NULL);
//if (player != NULL && player->isOnline() && !player->isLoggingOut())
if (player->isPlayerCreature())
player->sendSystemMessage("@group:removed");
player->unlock();
group->removeMember(player);
if (player->isPlayerCreature())
group->sendDestroyTo(player);
player->info("leaving group");
if (group->getGroupSize() < 2) {
group->disband();
}
} catch (Exception& e) {
System::out << e.getMessage();
e.printStackTrace();
} catch (...) {
player->wlock();
throw;
}
player->wlock();
}
void PetControlDeviceImplementation::setVitality(int vit) {
vitality = vit;
if (petType == PetManager::CREATUREPET || petType == PetManager::DROIDPET) {
ManagedReference<CreatureObject*> pet = this->controlledObject.get().castTo<CreatureObject*>();
if (controlledObject == NULL)
return;
float hamPenaltyModifier = 0;
if (vitality <= 75 && vitality > 50) {
hamPenaltyModifier = 0.25f;
}
else if (vitality <= 50 && vitality > 25) {
hamPenaltyModifier = 0.5f;
}
else if (vitality <= 25) {
hamPenaltyModifier = 0.75f;
}
Reference<PetControlDevice*> petControlDevice = _this.getReferenceUnsafeStaticCast();
float vitalityMindPenalty = this->vitalityMindPenalty;
float vitalityActionPenalty = this->vitalityActionPenalty;
float vitalityHealthPenalty = this->vitalityHealthPenalty;
Core::getTaskManager()->executeTask([pet, petControlDevice, hamPenaltyModifier, vitalityMindPenalty, vitalityActionPenalty, vitalityHealthPenalty] () {
Locker locker(pet);
Locker clocker(petControlDevice, pet);
int newVitalityHealthPenalty = pet->getBaseHAM(0) * hamPenaltyModifier;
int newVitalityActionPenalty = pet->getBaseHAM(3) * hamPenaltyModifier;
int newVitalityMindPenalty = pet->getBaseHAM(6) * hamPenaltyModifier;
if (newVitalityHealthPenalty != vitalityHealthPenalty) {
int change = vitalityHealthPenalty - newVitalityHealthPenalty;
petControlDevice->setVitalityHealthPenalty(newVitalityHealthPenalty);
}
if (newVitalityActionPenalty != vitalityActionPenalty) {
int change = vitalityActionPenalty - newVitalityActionPenalty;
pet->setMaxHAM(3, pet->getMaxHAM(3) + change, true);
petControlDevice->setVitalityActionPenalty(newVitalityActionPenalty);
}
if (newVitalityMindPenalty != vitalityMindPenalty) {
int change = vitalityMindPenalty - newVitalityMindPenalty;
pet->setMaxHAM(6, pet->getMaxHAM(6) + change, true);
petControlDevice->setVitalityMindPenalty(newVitalityMindPenalty);
}
}, "PetSetVitalityLambda");
}
}
void ImageDesignSessionImplementation::checkDequeueEvent(SceneObject* scene) {
ManagedReference<CreatureObject*> designerCreature = this->designerCreature.get();
ManagedReference<CreatureObject*> targetCreature = this->targetCreature.get();
if (targetCreature == NULL || designerCreature == NULL)
return;
if (scene == designerCreature) {
Locker clocker(targetCreature, designerCreature);
if (targetCreature->getParentRecursively(SceneObjectType::SALONBUILDING) == NULL || designerCreature->getParentRecursively(SceneObjectType::SALONBUILDING) == NULL)
return;
} else if (scene == targetCreature) {
Locker clocker(designerCreature, targetCreature);
if (targetCreature->getParentRecursively(SceneObjectType::SALONBUILDING) == NULL || designerCreature->getParentRecursively(SceneObjectType::SALONBUILDING) == NULL)
return;
}
dequeueIdTimeoutEvent();
}
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 GroupObjectImplementation::disband() {
// this locked
ManagedReference<ChatRoom* > chat = chatRoom;
for (int i = 0; i < groupMembers.size(); i++) {
if (groupMembers.get(i) == NULL) {
continue;
}
Reference<CreatureObject*> groupMember = getGroupMember(i).castTo<CreatureObject*>();
try {
Locker clocker(groupMember, _this.get());
if (groupMember->isPlayerCreature()) {
if (chat != NULL) {
chat->removePlayer(groupMember, false);
chat->sendDestroyTo(groupMember);
ChatRoom* room = chat->getParent();
room->sendDestroyTo(groupMember);
}
if (groupMember->getPlayerObject() != NULL) {
PlayerObject* ghost = groupMember->getPlayerObject();
ghost->removeWaypointBySpecialType(WaypointObject::SPECIALTYPE_NEARESTMISSIONFORGROUP);
}
}
groupMember->updateGroup(NULL);
//play->updateGroupId(0);
//sendClosestWaypointDestroyTo(play);
//removeSquadLeaderBonuses(play);
} catch (Exception& e) {
System::out << "Exception in GroupObject::disband(Player* player)\n";
}
}
destroyChatRoom();
if (hasSquadLeader())
removeGroupModifiers();
groupMembers.removeAll();
//The mission waypoints should not be destroyed. They belong to the players.
//missionWaypoints.removeAll();
}
void PlantObjectImplementation::changeSize(int size) {
String plantTemplate = "";
switch (size) {
case 0: plantTemplate = "object/tangible/loot/plant_grow/plant_stage_dead.iff"; break;
case 1: plantTemplate = "object/tangible/loot/plant_grow/plant_stage_1.iff"; break;
case 2: plantTemplate = "object/tangible/loot/plant_grow/plant_stage_2.iff"; break;
case 3: plantTemplate = "object/tangible/loot/plant_grow/plant_stage_3.iff"; break;
}
ManagedReference<ZoneServer*> zoneServer = getZoneServer();
if (zoneServer == NULL)
return;
ManagedReference<SceneObject*> parent = getParent();
if (parent == NULL || !parent->isCellObject())
return;
ManagedReference<SceneObject*> obj = zoneServer->createObject(plantTemplate.hashCode(), getPersistenceLevel());
if (obj == NULL)
return;
Locker clocker(obj, _this.getReferenceUnsafeStaticCast());
obj->initializePosition(getPositionX(), getPositionZ(), getPositionY());
obj->setDirection(Math::deg2rad(getDirectionAngle()));
ManagedReference<PlantObject*> newPlant = cast<PlantObject*>( obj.get());
if (newPlant == NULL)
return;
newPlant->setWaterLevel(waterLevel);
newPlant->setNutrientLevel(nutrientLevel);
newPlant->setWaterQuality(waterQuality);
newPlant->setNutrientQuality(nutrientQuality);
newPlant->setPlantHealth(health);
newPlant->initializePlant(size);
parent->transferObject(obj, -1);
clocker.release();
destroyObjectFromWorld(true);
destroyObjectFromDatabase();
}
void JukeboxImplementation::destroyObjectFromDatabase(bool destroyContainedObjects) {
ManagedReference<CreatureObject*> strongOwner = owner.get();
if (strongOwner != NULL) {
Locker clocker(strongOwner, _this.getReferenceUnsafeStaticCast());
PlayerObject* ghost = strongOwner->getPlayerObject();
if (ghost != NULL) {
ghost->removeEventPerk(_this.getReferenceUnsafeStaticCast());
}
}
TangibleObjectImplementation::destroyObjectFromDatabase(destroyContainedObjects);
}
