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