Reference<ResourceContainer*> ResourceSpawnImplementation::createResource(int units) {
Reference<ResourceContainer*> newResource = NULL;
newResource = (getZoneServer()->createObject(containerCRC, 2)).castTo<ResourceContainer*>();
if(newResource == NULL) {
error("Unable to create resource container, using generic. CRC attempted was: " + String::valueOf(containerCRC));
print();
String genericContainer = "object/resource_container/organic_food.iff";
newResource = (getZoneServer()->createObject(genericContainer.hashCode(), 2)).castTo<ResourceContainer*>();
}
Locker locker(newResource);
newResource->setSpawnObject(_this.getReferenceUnsafeStaticCast());
if (units != 0)
newResource->setQuantity(units);
String resourceName = getFinalClass() + " (" + getName() + ")";
newResource->setCustomObjectName(resourceName, false);
++containerReferenceCount;
return newResource;
}
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 InstallationObjectImplementation::handleStructureAddEnergy(CreatureObject* player) {
try {
StringBuffer sstext, ssTotalEnergy;
ManagedReference<SuiTransferBox*> energyBox = new SuiTransferBox(player, SuiWindowType::STRUCTURE_ADD_ENERGY);
energyBox->setUsingObject(_this.get());
energyBox->setPromptTitle("@player_structure:add_power");
sstext << "@player_structure:select_power_amount"
<<"\n\n@player_structure:current_power_value " << (int) surplusPower;
energyBox->setPromptText(sstext.toString());
ResourceManager* resourceManager = getZoneServer()->getResourceManager();
ssTotalEnergy << resourceManager->getAvailablePowerFromPlayer(player);
energyBox->addFrom("@player_structure:total_energy", ssTotalEnergy.toString(), ssTotalEnergy.toString(), "1");
energyBox->addTo("@player_structure:to_deposit", "0", "0", "1");
energyBox->setCallback(new InsertPowerSuiCallback(server->getZoneServer()));
player->getPlayerObject()->addSuiBox(energyBox);
player->sendMessage(energyBox->generateMessage());
} catch (Exception& e) {
e.printStackTrace();
error("unreported exception in InstallationObjectImplementation::handleStructureAddEnergy");
}
}
void LightsaberCrystalComponentImplementation::generateCrystalStats() {
ManagedReference<LootManager*> lootManager = getZoneServer()->getLootManager();
if (lootManager == NULL)
return;
CrystalData* crystalData = lootManager->getCrystalData(getObjectTemplate()->getTemplateFileName());
if (crystalData == NULL) {
error("Unable to find crystal stats for " + getObjectTemplate()->getTemplateFileName());
return;
}
int minStat = crystalData->getMinHitpoints();
int maxStat = crystalData->getMaxHitpoints();
setMaxCondition(getRandomizedStat(minStat, maxStat, itemLevel));
if (color == 31) {
int minStat = crystalData->getMinDamage();
int maxStat = crystalData->getMaxDamage();
damage = getRandomizedStat(minStat, maxStat, itemLevel);
minStat = crystalData->getMinHealthSac();
maxStat = crystalData->getMaxHealthSac();
sacHealth = getRandomizedStat(minStat, maxStat, itemLevel);
minStat = crystalData->getMinActionSac();
maxStat = crystalData->getMaxActionSac();
sacAction = getRandomizedStat(minStat, maxStat, itemLevel);
minStat = crystalData->getMinMindSac();
maxStat = crystalData->getMaxMindSac();
sacMind = getRandomizedStat(minStat, maxStat, itemLevel);
minStat = crystalData->getMinWoundChance();
maxStat = crystalData->getMaxWoundChance();
woundChance = getRandomizedStat(minStat, maxStat, itemLevel);
float minFloatStat = crystalData->getMinForceCost();
float maxFloatStat = crystalData->getMaxForceCost();
floatForceCost = getRandomizedStat(minFloatStat, maxFloatStat, itemLevel);
minFloatStat = crystalData->getMinAttackSpeed();
maxFloatStat = crystalData->getMaxAttackSpeed();
attackSpeed = Math::getPrecision(getRandomizedStat(minFloatStat, maxFloatStat, itemLevel), 2);
}
quality = getCrystalQuality();
}
WaypointObject* MissionObjectImplementation::createWaypoint() {
waypointToMission = ( getZoneServer()->createObject(0xc456e788, 1)).castTo<WaypointObject*>();
//obj->setPlanetCRC(planet.hashCode());
//obj->setPosition(positionX, 0, positionY);
waypointToMission->setActive(false);
waypointToMission->setColor(3);
return waypointToMission;
}
Reference<FactoryCrate*> TangibleObjectImplementation::createFactoryCrate(bool insertSelf) {
String file;
uint32 type = getGameObjectType();
if(type & SceneObjectType::ARMOR)
file = "object/factory/factory_crate_armor.iff";
else if(type == SceneObjectType::CHEMICAL || type == SceneObjectType::PHARMACEUTICAL || type == SceneObjectType::PETMEDECINE)
file = "object/factory/factory_crate_chemicals.iff";
else if(type & SceneObjectType::CLOTHING)
file = "object/factory/factory_crate_clothing.iff";
else if(type == SceneObjectType::ELECTRONICS)
file = "object/factory/factory_crate_electronics.iff";
else if(type == SceneObjectType::FOOD || type == SceneObjectType::DRINK)
file = "object/factory/factory_crate_food.iff";
else if(type == SceneObjectType::FURNITURE)
file = "object/factory/factory_crate_furniture.iff";
else if(type & SceneObjectType::INSTALLATION)
file = "object/factory/factory_crate_installation.iff";
else if(type & SceneObjectType::WEAPON)
file = "object/factory/factory_crate_weapon.iff";
else
file = "object/factory/factory_crate_generic_items.iff";
ObjectManager* objectManager = ObjectManager::instance();
Reference<FactoryCrate*> crate = (getZoneServer()->createObject(file.hashCode(), 2)).castTo<FactoryCrate*>();
if (crate == NULL)
return NULL;
SharedTangibleObjectTemplate* tanoData = dynamic_cast<SharedTangibleObjectTemplate*>(templateObject.get());
if (tanoData == NULL)
return NULL;
crate->setMaxCapacity(tanoData->getFactoryCrateSize());
if (insertSelf) {
crate->transferObject(_this.get(), -1, false);
} else {
ManagedReference<TangibleObject*> protoclone = cast<TangibleObject*>( objectManager->cloneObject(_this.get()));
if (protoclone == NULL)
return NULL;
protoclone->setParent(NULL);
crate->transferObject(protoclone, -1, false);
}
crate->setCustomObjectName(getCustomObjectName(), false);
crate->setUseCount(1);
return crate;
}
Reference<SceneObject*> SceneObjectImplementation::getCraftedComponentsSatchel() {
Reference<SceneObject*> sceno = asSceneObject();
if (sceno == NULL)
return NULL;
Reference<ZoneServer*> zServer = getZoneServer();
if(zServer == NULL)
return NULL;
ManagedReference<SceneObject*> craftingComponents = sceno->getSlottedObject("crafted_components");
ManagedReference<SceneObject*> craftingComponentsSatchel = NULL;
if(craftingComponents == NULL) {
/// Add Components to crafted object
String craftingComponentsPath = "object/tangible/crafting/crafting_components_container.iff";
craftingComponents = zServer->createObject(craftingComponentsPath.hashCode(), 1);
Locker componentsLocker(craftingComponents);
craftingComponents->setSendToClient(false);
sceno->transferObject(craftingComponents, 4, false);
craftingComponents->setContainerDefaultDenyPermission(ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponents->setContainerDefaultAllowPermission(0);
craftingComponents->setContainerDenyPermission("owner", ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponents->setContainerDenyPermission("admin", ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponents->setContainerAllowPermission("owner", 0);
craftingComponents->setContainerAllowPermission("admin", 0);
craftingComponents->setContainerInheritPermissionsFromParent(false);
//String craftingComponentsSatchelPath = "object/tangible/container/base/base_container_volume.iff";
String craftingComponentsSatchelPath = "object/tangible/hopper/crafting_station_hopper/crafting_station_ingredient_hopper_large.iff";
craftingComponentsSatchel = zServer->createObject(craftingComponentsSatchelPath.hashCode(), 1);
Locker satchelLocker(craftingComponentsSatchel, craftingComponents);
craftingComponentsSatchel->setContainerInheritPermissionsFromParent(false);
craftingComponentsSatchel->setContainerDefaultDenyPermission(ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponentsSatchel->setContainerDefaultAllowPermission(0);
craftingComponentsSatchel->setContainerAllowPermission("admin", ContainerPermissions::OPEN);
craftingComponentsSatchel->setContainerDenyPermission("admin", ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponentsSatchel->setContainerAllowPermission("owner", 0);
craftingComponentsSatchel->setContainerDenyPermission("owner", ContainerPermissions::OPEN + ContainerPermissions::MOVEIN + ContainerPermissions::MOVEOUT + ContainerPermissions::MOVECONTAINER);
craftingComponents->transferObject(craftingComponentsSatchel, -1, false);
} else {
craftingComponentsSatchel = craftingComponents->getContainerObject(0);
}
return craftingComponentsSatchel;
}
void InstallationObjectImplementation::createChildObjects(){
if( isTurret()) {
SharedInstallationObjectTemplate* inso = dynamic_cast<SharedInstallationObjectTemplate*>(getObjectTemplate());
if(inso != NULL){
uint32 defaultWeaponCRC = inso->getWeapon().hashCode();
if(getZoneServer() != NULL) {
Reference<WeaponObject*> defaultWeapon = (getZoneServer()->createObject(defaultWeaponCRC, 1)).castTo<WeaponObject*>();
if (defaultWeapon == NULL) {
return;
} else {
if (!transferObject(defaultWeapon, 4)) {
defaultWeapon->destroyObjectFromDatabase(true);
return;
}
if(dataObjectComponent != NULL){
TurretDataComponent* turretData = cast<TurretDataComponent*>(dataObjectComponent.get());
if(turretData != NULL) {
turretData->setWeapon(defaultWeapon);
}
}
}
}
}
} else if (isMinefield()){
this->setContainerDefaultAllowPermission(ContainerPermissions::MOVEIN);
this->setContainerDefaultDenyPermission(ContainerPermissions::MOVEOUT);
this->setContainerDefaultAllowPermission(ContainerPermissions::OPEN);
} else {
StructureObjectImplementation::createChildObjects();
}
}
void SceneObjectImplementation::destroyObjectFromDatabase(bool destroyContainedObjects) {
//info("deleting from database", true);
if (isPlayerCreature()) {
assert(0 && "attempting to delete a player creature from database");
}
if(dataObjectComponent != NULL) {
dataObjectComponent->notifyObjectDestroyingFromDatabase();
}
ZoneServer* server = getZoneServer();
server->destroyObjectFromDatabase(getObjectID());
asSceneObject()->setPersistent(0);
if (!destroyContainedObjects)
return;
SortedVector<ManagedReference<SceneObject*> > destroyedObjects;
destroyedObjects.setNoDuplicateInsertPlan();
for (int i = 0; i < getSlottedObjectsSize(); ++i) {
ManagedReference<SceneObject*> object = getSlottedObject(i);
if (destroyedObjects.put(object) != -1) {
Locker locker(object);
object->destroyObjectFromDatabase(true);
}
}
for (int j = 0; j < getContainerObjectsSize(); ++j) {
ManagedReference<SceneObject*> object = getContainerObject(j);
if (destroyedObjects.put(object) != -1) {
Locker locker(object);
object->destroyObjectFromDatabase(true);
}
}
//Remove all child objects from database
for (int i = 0; i < childObjects.size(); ++i) {
ManagedReference<SceneObject*> child = childObjects.get(i);
if (child == NULL)
continue;
Locker locker(child);
child->destroyObjectFromDatabase(true);
}
}
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 SceneObjectImplementation::broadcastDestroyPrivate(SceneObject* object, SceneObject* selfObject) {
ZoneServer* zoneServer = getZoneServer();
if (zoneServer != NULL && zoneServer->isServerLoading())
return;
if (parent.get() != NULL) {
ManagedReference<SceneObject*> grandParent = getRootParent().get();
if (grandParent != NULL) {
grandParent->broadcastDestroyPrivate(object, selfObject);
return;
} else {
return;
}
}
if (zone == NULL)
return;
SortedVector<ManagedReference<QuadTreeEntry*> > closeSceneObjects;
int maxInRangeObjectCount = 0;
if (closeobjects == NULL) {
info("Null closeobjects vector in SceneObjectImplementation::broadcastDestroyPrivate", true);
zone->getInRangeObjects(getPositionX(), getPositionY(), 256, &closeSceneObjects, true);
maxInRangeObjectCount = closeSceneObjects.size();
} else {
CloseObjectsVector* vec = (CloseObjectsVector*) closeobjects;
closeSceneObjects.removeAll(vec->size(), 10);
vec->safeCopyTo(closeSceneObjects);
maxInRangeObjectCount = closeSceneObjects.size();
}
for (int i = 0; i < maxInRangeObjectCount; ++i) {
SceneObject* scno = static_cast<SceneObject*>(closeSceneObjects.get(i).get());
ManagedReference<ZoneClientSession*> client = scno->getClient();
if (scno->isVehicleObject() || client != NULL || scno->isMount()) {
object->sendDestroyTo(scno);
}
}
}
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 FireworkObjectImplementation::beginShowLaunch(CreatureObject* player) {
if (player == NULL || player->getParent() != NULL)
return;
ManagedReference<FireworkObject*> fireworkShow = _this.getReferenceUnsafeStaticCast();
if (fireworkShow == NULL)
return;
DataObjectComponent* data = fireworkShow->getDataObjectComponent()->get();
if(data == NULL || !data->isFireworkShowData())
return;
FireworkShowDataComponent* fireworkShowData = cast<FireworkShowDataComponent*>(data);
if (fireworkShowData->getTotalFireworkCount() == 0)
return;
ManagedReference<StaticObject*> showLauncherObject = (getZoneServer()->createObject(fireworkObject.hashCode(), 0)).castTo<StaticObject*>();
if (showLauncherObject == NULL)
return;
player->setPosture(CreaturePosture::CROUCHED);
player->doAnimation("manipulate_low");
float angle = player->getDirectionAngle();
if (angle > 360)
angle = angle - 360;
float distance = 2.0;
angle = 2 * M_PI * angle / 360;
int x = player->getPositionX() + sin(angle) * (distance);
int y = player->getPositionY() + cos(angle) * (distance);
int z = player->getZone()->getHeight(x, y);
Locker locker(showLauncherObject);
showLauncherObject->initializePosition(x, z, y);
player->getZone()->transferObject(showLauncherObject, -1, true);
fireworkShow->destroyObjectFromWorld(true);
int launchDelay = fireworkShowData->getFireworkDelay(0);
Reference<FireworkShowLaunchFireworkEvent*> fireworkShowLaunchFireworkEvent = new FireworkShowLaunchFireworkEvent(player, fireworkShow, fireworkShowData, showLauncherObject);
fireworkShowLaunchFireworkEvent->schedule(launchDelay);
}
int MissionTerminalImplementation::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
ManagedReference<CityRegion*> city = player->getCityRegion();
if (selectedID == 69 && player->hasSkill("combat_smuggler_slicing_01")) {
if (city != NULL && !city->isClientRegion() && city->isBanned(player->getObjectID())) {
player->sendSystemMessage("@city/city:banned_services"); // You are banned from using this city's services.
return 0;
}
if (player->containsActiveSession(SessionFacadeType::SLICING)) {
player->sendSystemMessage("@slicing/slicing:already_slicing");
return 0;
}
if (!player->checkCooldownRecovery("slicing.terminal")) {
player->sendSystemMessage("@slicing/slicing:not_again");
return 0;
}
//Create Session
ManagedReference<SlicingSession*> session = new SlicingSession(player);
session->initalizeSlicingMenu(player, _this.getReferenceUnsafeStaticCast());
return 0;
} else if (selectedID == 72) {
if (city != NULL && city->isMayor(player->getObjectID())) {
CityRemoveAmenityTask* task = new CityRemoveAmenityTask(_this.getReferenceUnsafeStaticCast(), city);
task->execute();
player->sendSystemMessage("@city/city:mt_removed"); // The object has been removed from the city.
}
return 0;
} else if (selectedID == 74 || selectedID == 75 || selectedID == 76 || selectedID == 77) {
CityManager* cityManager = getZoneServer()->getCityManager();
cityManager->alignAmenity(city, player, _this.getReferenceUnsafeStaticCast(), selectedID - 74);
return 0;
}
return TangibleObjectImplementation::handleObjectMenuSelect(player, selectedID);
}
void InstallationObjectImplementation::changeActiveResourceID(uint64 spawnID) {
// Logic:
// 1) If operating, and already has an active resource ID - make sure the hopper gets updated
// 2) Get the spawn information & set the active resource id
// 3) If hopper size is zero for the resource + is operating, send a packet to the operators to add a zero element for delta packets
info("updating active ");
if (isOperating()) {
updateInstallationWork();
}
currentSpawn = getZoneServer()->getObject(spawnID).castTo<ResourceSpawn*>();
if (currentSpawn == NULL) {
error("new spawn null");
return;
}
Time timeToWorkTill;
Time currentTime;
resourceHopperTimestamp.updateToCurrentTime();
ManagedReference<ResourceContainer*> container = getContainerFromHopper(currentSpawn);
if (container == NULL) {
Locker locker(currentSpawn);
container = currentSpawn->createResource(0);
addResourceToHopper(container);
setActiveResource(container);
} else {
setActiveResource(container);
}
InstallationObjectDeltaMessage7* inso7 = new InstallationObjectDeltaMessage7( _this.get());
inso7->updateExtractionRate(getActualRate());
inso7->updateActiveResourceSpawn(getActiveResourceSpawnID());
inso7->close();
broadcastToOperators(inso7);
}
void InstallationObjectImplementation::destroyObjectFromDatabase(bool destroyContainedObjects) {
StructureObjectImplementation::destroyObjectFromDatabase(destroyContainedObjects);
if (!destroyContainedObjects)
return;
ManagedReference<SceneObject*> deed = getZoneServer()->getObject(deedObjectID);
if (deed != NULL) {
Locker locker(deed);
deed->destroyObjectFromDatabase(true);
}
for (int i = 0; i < resourceHopper.size(); ++i) {
ResourceContainer* container = resourceHopper.get(i);
Locker locker(container);
container->destroyObjectFromDatabase(true);
}
}
void FireworkObjectImplementation::completeLaunch(CreatureObject* player, int removeDelay) {
ManagedReference<StaticObject*> launcherObject = (getZoneServer()->createObject(fireworkObject.hashCode(), 0)).castTo<StaticObject*>();
if (launcherObject == NULL)
return;
player->setPosture(CreaturePosture::CROUCHED);
player->doAnimation("manipulate_low");
float angle = player->getDirectionAngle();
if (angle > 360)
angle = angle - 360;
float distance = 2.0;
angle = 2 * M_PI * angle / 360;
int x = player->getPositionX() + sin(angle) * (distance);
int y = player->getPositionY() + cos(angle) * (distance);
int z = player->getZone()->getHeight(x, y);
Locker locker(launcherObject);
launcherObject->initializePosition(x, z, y);
player->getZone()->transferObject(launcherObject, -1, true);
if (getUseCount() > 1) {
decreaseUseCount();
} else {
destroyObjectFromWorld(true);
if (isPersistent())
destroyObjectFromDatabase(true);
}
Reference<FireworkRemoveEvent*> fireworkRemoveEvent = new FireworkRemoveEvent(player, launcherObject);
fireworkRemoveEvent->schedule(removeDelay * 1000);
}
void PetControlDeviceImplementation::spawnObject(CreatureObject* player) {
ZoneServer* zoneServer = getZoneServer();
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL)
return;
assert(controlledObject->isLockedByCurrentThread());
if (!isASubChildOf(player))
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*> creature = NULL;
if (controlledObject->isCreatureObject()) {
creature = cast<CreatureObject*>(controlledObject.get());
creature->setCreatureLink(player);
creature->setControlDevice(_this.getReferenceUnsafeStaticCast());
creature->setFaction(player->getFaction());
creature->setObjectMenuComponent("PetMenuComponent");
if (player->getPvpStatusBitmask() & CreatureFlag::PLAYER)
creature->setPvpStatusBitmask(player->getPvpStatusBitmask() - CreatureFlag::PLAYER, true);
else
creature->setPvpStatusBitmask(player->getPvpStatusBitmask(), true);
if (trainedAsMount && (creature->getOptionsBitmask() ^ 0x1000)) {
creature->setOptionBit(0x1000);
}
}
Zone* zone = player->getZone();
if (zone == NULL)
return;
ManagedReference<CellObject*> parent = player->getParent().get().castTo<CellObject*>();
if (parent != NULL)
parent->transferObject(controlledObject, -1, true);
else
zone->transferObject(controlledObject, -1, true);
updateStatus(1);
if (petControlObserver != NULL)
player->dropObserver(ObserverEventType::STARTCOMBAT, petControlObserver);
AiAgent* pet = cast<AiAgent*>(creature.get());
if (pet == NULL)
return;
ManagedReference<PlayerObject*> ghost = player->getPlayerObject();
ghost->addToActivePets(pet);
bool isDroid = false;
if (pet->isDroidObject()) {
DroidObject* droid = cast<DroidObject*>(pet);
isDroid = true;
if( droid == NULL )
return;
// Sanity check that there aren't outstanding power/skill mod tasks
droid->removePendingTask( "droid_power" );
droid->removePendingTask( "droid_skill_mod" );
droid->initDroidModules();
droid->onCall();
droid->loadSkillMods(player);
// Submit new power task
Reference<Task*> droidPowerTask = new DroidPowerTask( droid );
droid->addPendingTask("droid_power", droidPowerTask, 120000); // 2 min
// Submit new skill mod task
Reference<Task*> droidSkillModTask = new DroidSkillModTask( droid, player );
droid->addPendingTask("droid_skill_mod", droidSkillModTask, 3000); // 3 sec
}
pet->setHomeLocation(player->getPositionX(), player->getPositionZ(), player->getPositionY(), parent);
pet->setNextStepPosition(player->getPositionX(), player->getPositionZ(), player->getPositionY(), parent);
pet->clearPatrolPoints();
if (petType == PetManager::CREATUREPET) {
pet->setCreatureBitmask(CreatureFlag::PET);
}
if (petType == PetManager::DROIDPET) {
pet->setCreatureBitmask(CreatureFlag::DROID_PET);
}
if (petType == PetManager::FACTIONPET) {
pet->setCreatureBitmask(CreatureFlag::FACTION_PET);
/** dont know if npc faction pets trained via converse instead of radial
if (pet->isNonPlayerCreatureObject() && pet->getDiet() != CreatureFlag::NONE) // show converse to npcs that eat food i.e. not atst
pet->setOptionBit(OptionBitmask::CONVERSE,true);
**/
}
pet->activateLoad("");
pet->activateRecovery();
// Not training any commands
trainingCommand = 0;
clearPatrolPoints();
}
void SceneObjectImplementation::broadcastMessagesPrivate(Vector<BasePacket*>* messages, SceneObject* selfObject) {
ZoneServer* zoneServer = getZoneServer();
if (zoneServer != NULL && zoneServer->isServerLoading())
return;
if (parent.get() != NULL) {
ManagedReference<SceneObject*> grandParent = cast<SceneObject*>(getRootParent().get().get());
if (grandParent != NULL) {
grandParent->broadcastMessagesPrivate(messages, selfObject);
return;
} else {
while (!messages->isEmpty()) {
delete messages->remove(0);
}
return;
}
}
if (zone == NULL) {
while (!messages->isEmpty()) {
delete messages->remove(0);
}
return;
}
//getZone()->rlock();
//Locker zoneLocker(zone);
bool readlock = !zone->isLockedByCurrentThread();
SortedVector<ManagedReference<QuadTreeEntry*> > closeSceneObjects;
int maxInRangeObjectCount = 0;
// zone->rlock(readlock);
try {
if (closeobjects == NULL) {
info(String::valueOf(getObjectID()) + " Null closeobjects vector in SceneObjectImplementation::broadcastMessagesPrivate", true);
zone->getInRangeObjects(getPositionX(), getPositionY(), 192, &closeSceneObjects, true);
maxInRangeObjectCount = closeSceneObjects.size();
} else {
maxInRangeObjectCount = closeobjects->size();
closeSceneObjects.removeAll(maxInRangeObjectCount, 10);
//closeSceneObjects.addAll(*closeobjects);
closeobjects->safeCopyTo(closeSceneObjects);
maxInRangeObjectCount = closeSceneObjects.size();
}
} catch (Exception& e) {
}
//getZone()->runlock();
//zoneLocker.release();
// zone->runlock(readlock);
for (int i = 0; i < maxInRangeObjectCount; ++i) {
SceneObject* scno = cast<SceneObject*>(closeSceneObjects.get(i).get());
if (selfObject == scno)
continue;
ManagedReference<ZoneClientSession*> client = scno->getClient();
if (scno->isVehicleObject() || client != NULL || scno->isMount()) {
for (int j = 0; j < messages->size(); ++j) {
BasePacket* msg = messages->get(j);
scno->sendMessage(msg->clone());
}
}
}
while (!messages->isEmpty()) {
delete messages->remove(0);
}
}
void SceneObjectImplementation::broadcastMessagePrivate(BasePacket* message, SceneObject* selfObject, bool lockZone) {
ZoneServer* zoneServer = getZoneServer();
if (zoneServer != NULL && zoneServer->isServerLoading())
return;
if (parent.get() != NULL) {
ManagedReference<SceneObject*> grandParent = cast<SceneObject*>(getRootParent().get().get());
if (grandParent != NULL) {
grandParent->broadcastMessagePrivate(message, selfObject, lockZone);
return;
} else {
delete message;
return;
}
}
if (zone == NULL) {
delete message;
return;
}
//Locker zoneLocker(zone);
//getZone()->rlock(lockZone);
// bool readlock = lockZone && !zone->isLockedByCurrentThread();
SortedVector<ManagedReference<QuadTreeEntry*> >* closeSceneObjects = NULL;
SortedVector<ManagedReference<QuadTreeEntry*> >* closeNoneReference = NULL;
int maxInRangeObjectCount = 0;
bool deleteVector = true;
try {
// zone->rlock(readlock);
if (closeobjects == NULL) {
info(String::valueOf(getObjectID()) + " Null closeobjects vector in SceneObjectImplementation::broadcastMessagePrivate", true);
closeSceneObjects = new SortedVector<ManagedReference<QuadTreeEntry*> >();
zone->getInRangeObjects(getPositionX(), getPositionY(), 192, closeSceneObjects, true);
maxInRangeObjectCount = closeSceneObjects->size();
deleteVector = true;
} else {
// maxInRangeObjectCount = closeobjects->size();
//closeSceneObjects = closeobjects;
closeNoneReference = new SortedVector<ManagedReference<QuadTreeEntry*> >(maxInRangeObjectCount, 50);
/* for (int i = 0; i < closeobjects->size(); ++i) {
closeNoneReference->add(closeobjects->get(i).get());
}
*/
closeobjects->safeCopyTo(*closeNoneReference);
maxInRangeObjectCount = closeNoneReference->size();
//closeSceneObjects.removeAll(maxInRangeObjectCount, 10);
//closeSceneObjects.addAll(*closeobjects);
}
/*
for (int i = 0; i < maxInRangeObjectCount; ++i) {
SceneObject* scno = cast<SceneObject*>(closeSceneObjects->get(i).get());
if (selfObject == scno)
continue;
ManagedReference<ZoneClientSession*> client = scno->getClient();
if (client != NULL || scno->isVehicleObject()) {
scno->sendMessage(message->clone());
}
}
*/
//zone->runlock(readlock);
} catch (...) {
// zone->runlock(readlock);
delete message;
throw;
}
for (int i = 0; i < maxInRangeObjectCount; ++i) {
SceneObject* scno;
if (closeSceneObjects != NULL)
scno = cast<SceneObject*>(closeSceneObjects->get(i).get());
else
scno = cast<SceneObject*>(closeNoneReference->get(i).get());
if (selfObject == scno)
continue;
ManagedReference<ZoneClientSession*> client = scno->getClient();
if ((dynamic_cast<VehicleObject*>(scno) != NULL) || client != NULL || scno->isMount())
scno->sendMessage(message->clone());
}
delete message;
if (closeSceneObjects != NULL)
delete closeSceneObjects;
else
delete closeNoneReference;
}
void SceneObjectImplementation::broadcastDestroyPrivate(SceneObject* object, SceneObject* selfObject) {
ZoneServer* zoneServer = getZoneServer();
if (zoneServer != NULL && zoneServer->isServerLoading())
return;
if (parent.get() != NULL) {
ManagedReference<SceneObject*> grandParent = cast<SceneObject*>(getRootParent().get().get());
if (grandParent != NULL) {
grandParent->broadcastDestroyPrivate(object, selfObject);
return;
} else {
return;
}
}
if (zone == NULL)
return;
//Locker zoneLocker(zone);
// bool readlock = !zone->isLockedByCurrentThread();
SortedVector<ManagedReference<QuadTreeEntry*> > closeSceneObjects;
int maxInRangeObjectCount = 0;
// zone->rlock(readlock);
try {
if (closeobjects == NULL) {
info("Null closeobjects vector in SceneObjectImplementation::broadcastDestroyPrivate", true);
zone->getInRangeObjects(getPositionX(), getPositionY(), 256, &closeSceneObjects, true);
maxInRangeObjectCount = closeSceneObjects.size();
} else {
CloseObjectsVector* vec = (CloseObjectsVector*) closeobjects;
closeSceneObjects.removeAll(vec->size(), 10);
// closeSceneObjects.addAll(*closeobjects);
vec->safeCopyTo(closeSceneObjects);
maxInRangeObjectCount = closeSceneObjects.size();//closeobjects->size();
}
} catch (...) {
//zone->runlock(readlock);
throw;
}
// zone->runlock(readlock);
for (int i = 0; i < maxInRangeObjectCount; ++i) {
SceneObject* scno = cast<SceneObject*>(closeSceneObjects.get(i).get());
if (selfObject == scno)
continue;
ManagedReference<ZoneClientSession*> client = scno->getClient();
if (scno->isVehicleObject() || client != NULL || scno->isMount()) {
object->sendDestroyTo(scno);
}
}
}
void SceneObjectImplementation::broadcastMessagePrivate(BasePacket* message, SceneObject* selfObject, bool lockZone) {
ZoneServer* zoneServer = getZoneServer();
if (zoneServer != NULL && zoneServer->isServerLoading())
return;
if (parent.get() != NULL) {
ManagedReference<SceneObject*> grandParent = getRootParent().get();
if (grandParent != NULL) {
grandParent->broadcastMessagePrivate(message, selfObject, lockZone);
return;
} else {
delete message;
return;
}
}
if (zone == NULL) {
delete message;
return;
}
SortedVector<ManagedReference<QuadTreeEntry*> >* closeSceneObjects = NULL;
SortedVector<ManagedReference<QuadTreeEntry*> >* closeNoneReference = NULL;
int maxInRangeObjectCount = 0;
bool deleteVector = true;
try {
if (closeobjects == NULL) {
info(String::valueOf(getObjectID()) + " Null closeobjects vector in SceneObjectImplementation::broadcastMessagePrivate", true);
closeSceneObjects = new SortedVector<ManagedReference<QuadTreeEntry*> >();
zone->getInRangeObjects(getPositionX(), getPositionY(), 192, closeSceneObjects, true);
maxInRangeObjectCount = closeSceneObjects->size();
deleteVector = true;
} else {
closeNoneReference = new SortedVector<ManagedReference<QuadTreeEntry*> >(maxInRangeObjectCount, 50);
closeobjects->safeCopyTo(*closeNoneReference);
maxInRangeObjectCount = closeNoneReference->size();
}
} catch (Exception& e) {
error(e.getMessage());
e.printStackTrace();
delete message;
throw;
} catch (...) {
delete message;
throw;
}
for (int i = 0; i < maxInRangeObjectCount; ++i) {
SceneObject* scno;
if (closeSceneObjects != NULL)
scno = static_cast<SceneObject*>(closeSceneObjects->get(i).get());
else
scno = static_cast<SceneObject*>(closeNoneReference->get(i).get());
ManagedReference<ZoneClientSession*> client = scno->getClient();
if (scno->isVehicleObject() || client != NULL || scno->isMount())
scno->sendMessage(message->clone());
}
delete message;
if (closeSceneObjects != NULL)
delete closeSceneObjects;
else
delete closeNoneReference;
}
void PetControlDeviceImplementation::spawnObject(CreatureObject* player) {
ZoneServer* zoneServer = getZoneServer();
ManagedReference<TangibleObject*> controlledObject = this->controlledObject.get();
if (controlledObject == NULL)
return;
if (!isASubChildOf(player))
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*> creature = NULL;
if (controlledObject->isCreatureObject()) {
creature = cast<CreatureObject*>(controlledObject.get());
creature->setCreatureLink(player);
creature->setControlDevice(_this.get());
creature->setFaction(player->getFaction());
creature->setObjectMenuComponent("PetMenuComponent");
if (player->getPvpStatusBitmask() & CreatureFlag::PLAYER)
creature->setPvpStatusBitmask(player->getPvpStatusBitmask() - CreatureFlag::PLAYER, true);
else
creature->setPvpStatusBitmask(player->getPvpStatusBitmask(), true);
}
Zone* zone = player->getZone();
if (zone == NULL)
return;
ManagedReference<SceneObject*> parent = player->getParent();
if (parent != NULL && parent->isCellObject())
parent->transferObject(controlledObject, -1, true);
else
zone->transferObject(controlledObject, -1, true);
updateStatus(1);
if (petControlObserver != NULL)
player->dropObserver(ObserverEventType::STARTCOMBAT, petControlObserver);
AiAgent* pet = cast<AiAgent*>(creature.get());
if (pet == NULL)
return;
ManagedReference<PlayerObject*> ghost = player->getPlayerObject();
ghost->addToActivePets(pet);
if (pet->isDroidObject()) {
DroidObject* droid = cast<DroidObject*>(pet);
if( droid == NULL )
return;
// Sanity check that there isn't another power task outstanding
droid->removePendingTask( "droid_power" );
// Submit new power task
Reference<Task*> droidPowerTask = new DroidPowerTask( droid );
droid->addPendingTask("droid_power", droidPowerTask, 120000); // 2 min
if( droid->hasPower() ){
// TODO Temporarily set to autofollow player
droid->setFollowObject(player);
}
else{
droid->handleLowPower();
}
} else {
pet->setFollowObject(player);
}
// Not training any commands
trainingCommand = 0;
}
void LightsaberCrystalComponentImplementation::validateCrystalStats() {
ManagedReference<LootManager*> lootManager = getZoneServer()->getLootManager();
if (lootManager == NULL)
return;
CrystalData* crystalData = lootManager->getCrystalData(getObjectTemplate()->getTemplateFileName());
if (crystalData == NULL) {
error("Unable to find crystal stats for " + getObjectTemplate()->getTemplateFileName());
return;
}
int minStat = crystalData->getMinHitpoints();
int maxStat = crystalData->getMaxHitpoints();
if (getMaxCondition() > maxStat || getMaxCondition() < minStat)
setMaxCondition(getRandomizedStat(minStat, maxStat, itemLevel));
if (color == 31) {
minStat = crystalData->getMinDamage();
maxStat = crystalData->getMaxDamage();
if (damage > maxStat || damage < minStat)
damage = getRandomizedStat(minStat, maxStat, itemLevel);
minStat = crystalData->getMinHealthSac();
maxStat = crystalData->getMaxHealthSac();
if (sacHealth > maxStat || sacHealth < minStat)
sacHealth = getRandomizedStat(minStat, maxStat, itemLevel);
minStat = crystalData->getMinActionSac();
maxStat = crystalData->getMaxActionSac();
if (sacAction > maxStat || sacAction < minStat)
sacAction = getRandomizedStat(minStat, maxStat, itemLevel);
minStat = crystalData->getMinMindSac();
maxStat = crystalData->getMaxMindSac();
if (sacMind > maxStat || sacMind < minStat)
sacMind = getRandomizedStat(minStat, maxStat, itemLevel);
minStat = crystalData->getMinWoundChance();
maxStat = crystalData->getMaxWoundChance();
if (woundChance > maxStat || woundChance < minStat)
woundChance = getRandomizedStat(minStat, maxStat, itemLevel);
float minFloatStat = crystalData->getMinForceCost();
float maxFloatStat = crystalData->getMaxForceCost();
if (floatForceCost > maxFloatStat || floatForceCost < minFloatStat)
floatForceCost = getRandomizedStat(minFloatStat, maxFloatStat, itemLevel);
minFloatStat = crystalData->getMinAttackSpeed();
maxFloatStat = crystalData->getMaxAttackSpeed();
if (attackSpeed > maxFloatStat || attackSpeed < minFloatStat)
attackSpeed = Math::getPrecision(getRandomizedStat(minFloatStat, maxFloatStat, itemLevel), 2);
}
}