void PlayerCreationManager::addStartingItems(CreatureObject* creature,
const String& clientTemplate, bool equipmentOnly) {
SortedVector < String > *items = NULL;
if (!defaultCharacterEquipment.contains(clientTemplate))
items = &defaultCharacterEquipment.get(0);
else
items = &defaultCharacterEquipment.get(clientTemplate);
for (int i = 0; i < items->size(); ++i) {
String itemTemplate = items->get(i);
//instance()->info("Add Starting Items: " + itemTemplate, true);
ManagedReference<SceneObject*> item = zoneServer->createObject(
itemTemplate.hashCode(), 1);
if (item != NULL) {
String error;
if (creature->canAddObject(item, 4, error) == 0) {
creature->transferObject(item, 4, false);
} else {
item->destroyObjectFromDatabase(true);
}
}
}
// Get inventory.
if (!equipmentOnly) {
SceneObject* inventory = creature->getSlottedObject("inventory");
if (inventory == NULL) {
return;
}
//Add common starting items.
for (int itemNumber = 0; itemNumber < commonStartingItems.size();
itemNumber++) {
ManagedReference<SceneObject*> item = zoneServer->createObject(
commonStartingItems.get(itemNumber).hashCode(), 1);
if (item != NULL) {
if (!inventory->transferObject(item, -1, false)) {
item->destroyObjectFromDatabase(true);
}
}
}
}
}
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 CellObjectImplementation::destroyAllPlayerItems() {
ManagedReference<SceneObject*> strongParent = getParent().get();
if (strongParent == NULL)
return;
int containerSize = getContainerObjectsSize();
for (int j = containerSize - 1; j >= 0; --j) {
ReadLocker rlocker(getContainerLock());
ManagedReference<SceneObject*> containerObject = getContainerObject(j);
rlocker.release();
if (strongParent->containsChildObject(containerObject))
continue;
if (containerObject->isCreatureObject())
continue;
containerObject->destroyObjectFromWorld(true);
//containerObject->broadcastDestroy(containerObject, false);
//removeObject(containerObject, false);
containerObject->destroyObjectFromDatabase(true);
}
}
void SlicingSessionImplementation::handleUseClamp() {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (player == NULL || tangibleObject == NULL)
return;
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
Locker inventoryLocker(inventory);
for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i);
uint32 objType = sceno->getGameObjectType();
if (objType == SceneObjectType::MOLECULARCLAMP) {
Locker locker(sceno);
sceno->destroyObjectFromWorld(true);
sceno->destroyObjectFromDatabase(true);
player->sendSystemMessage("@slicing/slicing:used_clamp");
usedClamp = true;
return;
}
}
player->sendSystemMessage("@slicing/slicing:no_clamp");
}
bool SlicingSessionImplementation::hasArmorUpgradeKit() {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (player == NULL)
return false;
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
if (inventory == NULL)
return false;
for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i);
uint32 objType = sceno->getGameObjectType();
if (objType == SceneObjectType::ARMORUPGRADEKIT) {
Locker locker(sceno);
sceno->destroyObjectFromWorld(true);
sceno->destroyObjectFromDatabase(true);
return true;
}
}
return false;
}
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;
}
Reference<SceneObject*> PlanetManagerImplementation::createTicket(const String& departurePoint, const String& arrivalPlanet, const String& arrivalPoint) {
ManagedReference<SceneObject*> obj = server->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/travel/travel_ticket/base/base_travel_ticket.iff"), 1);
if (obj == NULL)
return NULL;
if (!obj->isTangibleObject()) {
obj->destroyObjectFromDatabase(true);
return NULL;
}
TangibleObject* tano = cast<TangibleObject*>( obj.get());
if (!tano->isTicketObject()) {
tano->destroyObjectFromDatabase(true);
return NULL;
}
TicketObject* ticket = cast<TicketObject*>( tano);
ticket->setDeparturePlanet(zone->getZoneName());
ticket->setDeparturePoint(departurePoint);
ticket->setArrivalPlanet(arrivalPlanet);
ticket->setArrivalPoint(arrivalPoint);
return ticket;
}
void WeaponObjectImplementation::createChildObjects() {
// Create any child objects in a weapon.
ZoneServer* zoneServer = server->getZoneServer();
for (int i = 0; i < templateObject->getChildObjectsSize(); ++i) {
ChildObject* child = templateObject->getChildObject(i);
if (child == NULL)
continue;
ManagedReference<SceneObject*> obj = zoneServer->createObject(
child->getTemplateFile().hashCode(), getPersistenceLevel());
if (obj == NULL)
continue;
ContainerPermissions* permissions = obj->getContainerPermissions();
permissions->setOwner(getObjectID());
permissions->setInheritPermissionsFromParent(true);
permissions->setDefaultDenyPermission(ContainerPermissions::MOVECONTAINER);
permissions->setDenyPermission("owner", ContainerPermissions::MOVECONTAINER);
if (!transferObject(obj, child->getContainmentType())) {
obj->destroyObjectFromDatabase(true);
continue;
}
childObjects.put(obj);
obj->initializeChildObject(_this.getReferenceUnsafeStaticCast());
}
}
TangibleObject* ImageDesignManager::updateHairObject(CreatureObject* creo, TangibleObject* hairObject) {
if (creo == NULL)
return NULL;
ManagedReference<TangibleObject*> hair = creo->getSlottedObject("hair").castTo<TangibleObject*>();
if (hair == hairObject) {
return hairObject;
}
if (hair != NULL) {
Locker locker(hair);
hair->destroyObjectFromWorld(true);
hair->destroyObjectFromDatabase(true);
}
if (hairObject == NULL)
return NULL;
// Some race condition in the client prevents both the destroy and transfer from happening too close together
// Without it placing a hair object in the inventory.
ManagedReference<CreatureObject*> strongCreo = creo;
ManagedReference<TangibleObject*> strongHair = hairObject;
Core::getTaskManager()->scheduleTask([strongCreo, strongHair]{
Locker locker(strongCreo);
Locker cLocker(strongCreo, strongHair);
strongCreo->transferObject(strongHair, 4);
strongCreo->broadcastObject(strongHair, true);
}, "TransferHairTask", 100);
return hair;
}
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());
_this.get()->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)
object->destroyObjectFromDatabase(true);
}
for (int j = 0; j < getContainerObjectsSize(); ++j) {
ManagedReference<SceneObject*> object = getContainerObject(j);
if (destroyedObjects.put(object) != -1)
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;
child->destroyObjectFromDatabase(true);
}
}
int WeaponObjectMenuComponent::handleObjectMenuSelect(SceneObject* sceneObject, CreatureObject* player, byte selectedID) {
if (!sceneObject->isTangibleObject())
return 0;
ManagedReference<WeaponObject*> weapon = cast<WeaponObject*>(sceneObject);
if(weapon == NULL)
return 1;
if(weapon->isASubChildOf(player)) {
if (selectedID == 69 && player->hasSkill("combat_smuggler_slicing_02")) {
if (weapon->isSliced()) {
player->sendSystemMessage("@slicing/slicing:already_sliced");
return 0;
}
ManagedReference<Facade*> facade = player->getActiveSession(SessionFacadeType::SLICING);
ManagedReference<SlicingSession*> session = dynamic_cast<SlicingSession*>(facade.get());
if (session != NULL) {
player->sendSystemMessage("@slicing/slicing:already_slicing");
return 0;
}
//Create Session
session = new SlicingSession(player);
session->initalizeSlicingMenu(player, weapon);
return 0;
}
if(selectedID == 70) {
weapon->repair(player);
return 1;
}
if(selectedID == 71) {
ManagedReference<PowerupObject*> pup = weapon->removePowerup();
if(pup == NULL)
return 1;
Locker locker(pup);
pup->destroyObjectFromWorld( true );
pup->destroyObjectFromDatabase( true );
StringIdChatParameter message("powerup", "prose_remove_powerup"); //You detach your powerup from %TT.
message.setTT(weapon->getDisplayedName());
player->sendSystemMessage(message);
return 1;
}
}
return TangibleObjectMenuComponent::handleObjectMenuSelect(sceneObject, player, selectedID);
}
bool CreatureManagerImplementation::addWearableItem(CreatureObject* creature, TangibleObject* clothing) {
if (!clothing->isWearableObject() && !clothing->isWeaponObject())
return false;
ChatManager* chatMan = zoneServer->getChatManager();
SharedTangibleObjectTemplate* tanoData = dynamic_cast<SharedTangibleObjectTemplate*>(clothing->getObjectTemplate());
Vector<uint32>* races = tanoData->getPlayerRaces();
String race = creature->getObjectTemplate()->getFullTemplateString();
if(clothing->isWearableObject()) {
if (!races->contains(race.hashCode())) {
UnicodeString message;
if(creature->getObjectTemplate()->getFullTemplateString().contains("ithorian"))
message = "@player_structure:wear_not_ithorian";
else
message = "@player_structure:wear_no";
chatMan->broadcastMessage(creature, message, clothing->getObjectID(), creature->getMoodID(), 0);
return false;
}
}
ManagedReference<SceneObject*> clothingParent = clothing->getParent();
if (clothingParent == NULL)
return false;
for (int i = 0; i < clothing->getArrangementDescriptorSize(); ++i) {
Vector<String> descriptors = clothing->getArrangementDescriptor(i);
for (int j = 0; j < descriptors.size(); ++j) {
ManagedReference<SceneObject*> slot = creature->getSlottedObject(descriptors.get(j));
if (slot != NULL) {
slot->destroyObjectFromWorld(true);
slot->destroyObjectFromDatabase(true);
}
}
}
creature->transferObject(clothing, 4, false);
creature->doAnimation("pose_proudly");
creature->broadcastObject(clothing, true);
UnicodeString message;
if(clothing->isWeaponObject())
message = "@player_structure:wear_yes_weapon";
else
message = "@player_structure:wear_yes";
chatMan->broadcastMessage(creature, message, clothing->getObjectID(), creature->getMoodID(), 0);
return true;
}
void PetManagerImplementation::killPet(TangibleObject* attacker, AiAgent* pet) {
// TODO REMOVE AFTER TESTING
bool attackerIsAdmin = false;
// END REMOVE
StringIdChatParameter stringId;
if (attacker->isPlayerCreature()) {
stringId.setStringId("base_player", "prose_target_dead");
stringId.setTT(pet->getObjectID());
(cast<CreatureObject*>(attacker))->sendSystemMessage(stringId);
// TODO REMOVE AFTER TESTING
//ManagedReference<PlayerObject*> ghost = (cast<CreatureObject*>(attacker))->getPlayerObject();
//if (ghost != NULL && ghost->isPrivileged())
// attackerIsAdmin = true;
// END REMOVE
}
pet->setCurrentSpeed(0);
pet->clearCombatState(true);
pet->setPosture(CreaturePosture::DEAD, true);
pet->updateLocomotion();
pet->updateTimeOfDeath();
pet->clearBuffs(false);
ManagedReference<PetControlDevice*> petControlDevice = pet->getControlDevice().get().castTo<PetControlDevice*>();
if (petControlDevice != NULL) {
if (petControlDevice->getPetType() == FACTIONPET) {
ManagedReference<CreatureObject*> owner = zoneServer->getObject(pet->getCreatureLinkID()).castTo<CreatureObject*>();
if (owner != NULL)
petControlDevice->storeObject(owner, true);
petControlDevice->destroyObjectFromWorld(true);
petControlDevice->destroyObjectFromDatabase(true);
} else if ( (!attacker->isPlayerCreature() && !attacker->isPet()) || attackerIsAdmin) { // TODO REMOVE attackerIsAdmin AFTER TESTING
if (pet->getCooldownTimerMap() != NULL && pet->getCooldownTimerMap()->isPast("vitalityLossCooldown")) {
petControlDevice->setVitality(petControlDevice->getVitality() - 2);
pet->getCooldownTimerMap()->updateToCurrentAndAddMili("vitalityLossCooldown", 300000);
}
}
}
pet->notifyObjectKillObservers(attacker);
}
CreatureObject* CreatureManagerImplementation::createCreature(uint32 templateCRC, bool persistent, uint32 mobileTemplateCRC) {
ManagedReference<SceneObject*> object = zoneServer->createObject(templateCRC, persistent);
if (object == NULL) {
StringBuffer errMsg;
errMsg << "could not spawn creature... wrong template? 0x" << hex << templateCRC;
error(errMsg.toString());
return NULL;
}
Locker locker(object);
if (!object->isCreatureObject()) {
StringBuffer errMsg;
errMsg << "server did not create a creature object wrong template? 0x" << hex << templateCRC;
error(errMsg.toString());
if (object->isPersistent()) {
object->destroyObjectFromDatabase(true);
}
return NULL;
}
CreatureObject* creature = cast<CreatureObject*>( object.get());
if (!createCreatureChildrenObjects(creature, templateCRC, creature->isPersistent(), mobileTemplateCRC)) {
StringBuffer errMsg;
errMsg << "could not create children objects for creature... 0x" << templateCRC;
error(errMsg.toString());
if (object->isPersistent()) {
object->destroyObjectFromDatabase(true);
}
return NULL;
}
return creature;
}
TangibleObject* ImageDesignManager::createHairObject(CreatureObject* imageDesigner, CreatureObject* targetObject, const String& hairTemplate, const String& hairCustomization) {
Reference<TangibleObject*> oldHair = targetObject->getSlottedObject("hair").castTo<TangibleObject*>();
HairAssetData* hairAssetData = CustomizationIdManager::instance()->getHairAssetData(hairTemplate);
if (hairTemplate.isEmpty()) {
if (!CustomizationIdManager::instance()->canBeBald(getSpeciesGenderString(targetObject)))
return oldHair;
else
return NULL;
}
if (hairAssetData == NULL)
return oldHair;
int skillMod = hairAssetData->getSkillModValue();
if (imageDesigner->getSkillMod("hair") < skillMod)
return oldHair;
if (hairAssetData->getServerPlayerTemplate() != targetObject->getObjectTemplate()->getFullTemplateString()) {
error("hair " + hairTemplate + " is not compatible with this creature player " + targetObject->getObjectTemplate()->getFullTemplateString());
return oldHair;
}
ManagedReference<SceneObject*> hair = imageDesigner->getZoneServer()->createObject(hairTemplate.hashCode(), 1);
//TODO: Validate hairCustomization
if (hair == NULL || !hair->isTangibleObject()) {
if (hair != NULL) {
Locker locker(hair);
hair->destroyObjectFromDatabase(true);
}
return oldHair;
}
TangibleObject* tanoHair = cast<TangibleObject*>( hair.get());
Locker locker(tanoHair);
tanoHair->setContainerDenyPermission("owner", ContainerPermissions::MOVECONTAINER);
tanoHair->setContainerDefaultDenyPermission(ContainerPermissions::MOVECONTAINER);
String appearanceFilename = tanoHair->getObjectTemplate()->getAppearanceFilename();
CustomizationVariables data;
data.parseFromClientString(hairCustomization);
if (validateCustomizationString(&data, appearanceFilename, getSkillLevel(imageDesigner, "hair")))
tanoHair->setCustomizationString(hairCustomization);
return tanoHair;
}
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 DestroyMissionObjectiveImplementation::destroyObjectFromDatabase() {
MissionObjectiveImplementation::destroyObjectFromDatabase();
ManagedReference<MissionSpawnActiveArea* > spawnActiveArea = this->spawnActiveArea;
if (spawnActiveArea != NULL) {
Locker locker(spawnActiveArea);
spawnActiveArea->destroyObjectFromWorld(true);
spawnActiveArea->destroyObjectFromDatabase(true);
this->spawnActiveArea = NULL;
}
}
void CityRegionImplementation::removeAllDecorations() {
Locker slocker(&structureListMutex);
for (int i = cityDecorations.size() - 1; i >= 0 ; --i) {
ManagedReference<SceneObject*> dec = cityDecorations.get(i);
if(dec->isStructureObject()) {
StructureManager::instance()->destroyStructure(cast<StructureObject*>(dec.get()));
} else {
dec->destroyObjectFromWorld(false);
dec->destroyObjectFromDatabase(true);
}
}
cityDecorations.removeAll();
}
void CreateVendorSessionImplementation::randomizeVendorClothing(CreatureObject* vendor, VendorCreatureTemplate* vendorTempl) {
String randomOutfit = vendorTempl->getOutfitName(System::random(vendorTempl->getOutfitsSize() -1));
if (randomOutfit.isEmpty())
return;
Reference<Outfit*> outfit = VendorOutfitManager::instance()->getOutfit(randomOutfit);
if (outfit == NULL)
return;
Vector<uint32>* clothing = outfit->getClothing();
for (int i = 0; i < clothing->size(); ++i) {
ManagedReference<SceneObject*> obj = player->getZoneServer()->createObject(clothing->get(i), 1);
if (obj == NULL)
continue;
for (int j = 0; j < obj->getArrangementDescriptorSize(); ++j) {
const Vector<String>* descriptors = obj->getArrangementDescriptor(j);
for (int k = 0; k < descriptors->size(); ++k) {
ManagedReference<SceneObject*> slot = vendor->getSlottedObject(descriptors->get(k));
if (slot != NULL) {
slot->destroyObjectFromWorld(true);
slot->destroyObjectFromDatabase(true);
}
}
}
if (!vendor->transferObject(obj, 4)) {
obj->destroyObjectFromDatabase(true);
}
}
}
void SceneObjectImplementation::destroyChildObjects() {
int size = childObjects.size();
for (int i = 0; i < size; i++) {
ManagedReference<SceneObject*> child = childObjects.get(0);
if (child == NULL)
continue;
Locker clocker(child, asSceneObject());
childObjects.drop(child);
child->destroyObjectFromDatabase(true);
child->destroyObjectFromWorld(true);
}
}
void PlayerCreationManager::addRacialMods(CreatureObject* creature,
const String& race, Vector<String>* startingSkills,
Vector<String>* startingItems, bool equipmentOnly) {
Reference<RacialCreationData*> racialData = racialCreationData.get(race);
if (racialData == NULL)
racialData = racialCreationData.get(0);
for (int i = 0; i < 6; i++) {
int mod = racialData->getAttributeMod(i) + creature->getBaseHAM(i);
creature->setBaseHAM(i, mod, false);
creature->setHAM(i, mod, false);
creature->setMaxHAM(i, mod, false);
}
PlayerObject* ghost = creature->getPlayerObject();
SkillManager::instance()->awardSkill("combat_marksman_novice",creature, false, true, true);
SkillManager::instance()->awardSkill("combat_brawler_novice",creature, false, true, true);
SkillManager::instance()->awardSkill("crafting_artisan_novice",creature, false, true, true);
SkillManager::instance()->awardSkill("science_medic_novice",creature, false, true, true);
SkillManager::instance()->awardSkill("social_entertainer_novice",creature, false, true, true);
SkillManager::instance()->awardSkill("outdoors_scout_novice",creature, false, true, true);
SkillManager::instance()->addAbility(ghost, "rangedShot", false);
SkillManager::instance()->addAbility(ghost, "meleeHit", false); //Crappy but works for now.
// Get inventory.
if (!equipmentOnly) {
SceneObject* inventory = creature->getSlottedObject("inventory");
if (inventory == NULL) {
return;
}
if (startingItems != NULL) {
for (int i = 0; i < startingItems->size(); ++i) {
ManagedReference<SceneObject*> item = zoneServer->createObject(
startingItems->get(i).hashCode(), 1);
if (item != NULL) {
if (!inventory->transferObject(item, -1, false)) {
item->destroyObjectFromDatabase(true);
}
}
}
}
}
}
void PlayerCreationManager::addRacialMods(CreatureObject* creature,
const String& race, Vector<String>* startingSkills,
Vector<String>* startingItems, bool equipmentOnly) {
Reference<RacialCreationData*> racialData = racialCreationData.get(race);
if (racialData == NULL)
racialData = racialCreationData.get(0);
for (int i = 0; i < 9; ++i) {
int mod = racialData->getAttributeMod(i) + creature->getBaseHAM(i);
creature->setBaseHAM(i, mod, false);
creature->setHAM(i, mod, false);
creature->setMaxHAM(i, mod, false);
}
if (startingSkills != NULL) {
for (int i = 0; i < startingSkills->size(); ++i) {
SkillManager::instance()->awardSkill(startingSkills->get(i),
creature, false, true, true);
}
}
// Get inventory.
if (!equipmentOnly) {
SceneObject* inventory = creature->getSlottedObject("inventory");
if (inventory == NULL) {
return;
}
if (startingItems != NULL) {
for (int i = 0; i < startingItems->size(); ++i) {
ManagedReference<SceneObject*> item = zoneServer->createObject(
startingItems->get(i).hashCode(), 1);
if (item != NULL) {
if (!inventory->transferObject(item, -1, false)) {
item->destroyObjectFromDatabase(true);
}
}
}
}
}
}
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 WeaponObjectImplementation::decreasePowerupUses(CreatureObject* player) {
if (hasPowerup()) {
powerupObject->decreaseUses();
if (powerupObject->getUses() < 1) {
Locker locker(_this.getReferenceUnsafeStaticCast());
StringIdChatParameter message("powerup", "prose_pup_expire"); //The powerup on your %TT has expired.
message.setTT(getDisplayedName());
player->sendSystemMessage(message);
ManagedReference<PowerupObject*> pup = removePowerup();
if(pup != NULL) {
Locker plocker(pup);
pup->destroyObjectFromWorld( true );
pup->destroyObjectFromDatabase( true );
}
}
sendAttributeListTo(player);
}
}
void SlicingSessionImplementation::handleUseFlowAnalyzer() {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (player == NULL || tangibleObject == NULL)
return;
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
Locker inventoryLocker(inventory);
for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i);
uint32 objType = sceno->getGameObjectType();
if (objType == SceneObjectType::FLOWANALYZER) {
SlicingTool* node = cast<SlicingTool*>( sceno.get());
nodeCable = node->calculateSuccessRate();
if (nodeCable) // PASSED
nodeCable = firstCable;
else if (nodeCable == firstCable) { // Failed but the cables are Correct
if (firstCable)
nodeCable = 0; // Failed - Make the Cable incorrect
}
Locker locker(sceno);
sceno->destroyObjectFromWorld(true);
sceno->destroyObjectFromDatabase(true);
player->sendSystemMessage("@slicing/slicing:used_node");
usedNode = true;
return;
}
}
player->sendSystemMessage("@slicing/slicing:no_node");
}
TangibleObject* ImageDesignManager::updateHairObject(CreatureObject* creo, TangibleObject* hairObject) {
if (creo == NULL)
return NULL;
ManagedReference<TangibleObject*> hair = creo->getSlottedObject("hair").castTo<TangibleObject*>();
if (hair != NULL) {
Locker locker(hair);
hair->destroyObjectFromWorld(true);
hair->destroyObjectFromDatabase(true);
}
if (hairObject == NULL)
return NULL;
Locker locker(hairObject);
creo->transferObject(hairObject, 4);
creo->broadcastObject(hairObject, true);
return hair;
}
void CityRegionImplementation::setRadius(float rad) {
if (regions.size() <= 0)
return;
ManagedReference<Region*> oldRegion = regions.get(0).get();
ManagedReference<Region*> newRegion = addRegion(oldRegion->getPositionX(), oldRegion->getPositionY(), rad, true);
Locker locker(oldRegion, _this.getReferenceUnsafeStaticCast());
zone->removeObject(oldRegion, NULL, false);
regions.drop(oldRegion);
oldRegion->destroyObjectFromDatabase(true);
locker.release();
if (registered) {
Reference<PlanetMapCategory*> cityCat = TemplateManager::instance()->getPlanetMapCategoryByName("city");
newRegion->setPlanetMapCategory(cityCat);
newRegion->getZone()->registerObjectWithPlanetaryMap(newRegion);
}
}
void FireworkObjectImplementation::destroyObjectFromDatabase(bool destroyContainedObjects) {
ManagedReference<FireworkObject*> firework = _this.getReferenceUnsafeStaticCast();
if (firework != NULL && firework->isFireworkObject()) {
DataObjectComponent* data = firework->getDataObjectComponent()->get();
if(data != NULL && data->isFireworkShowData()) {
FireworkShowDataComponent* fireworkShowData = cast<FireworkShowDataComponent*>(data);
if (fireworkShowData->getTotalFireworkCount() > 0) {
for (int i=0; i< fireworkShowData->getTotalFireworkCount(); i++) {
ManagedReference<FireworkObject*> firework = fireworkShowData->getFirework(0);
fireworkShowData->removeFirework(0);
if (firework != NULL)
firework->destroyObjectFromDatabase(false);
}
}
}
}
TangibleObjectImplementation::destroyObjectFromDatabase(destroyContainedObjects);
}
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; // 1 highest 7 lowest
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);
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
if (inventory->hasFullContainerObjects()) {
StringIdChatParameter err("survey", "no_inv_space");
player->sendSystemMessage(err);
player->setPosture(CreaturePosture::UPRIGHT, true);
return;
}
// 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());
if (deed->isSpecialResist(WeaponObject::STUN))
prototype->setSpecialResist(WeaponObject::STUN);
if (deed->isSpecialResist(WeaponObject::KINETIC))
prototype->setSpecialResist(WeaponObject::KINETIC);
if (deed->isSpecialResist(WeaponObject::ENERGY))
prototype->setSpecialResist(WeaponObject::ENERGY);
if (deed->isSpecialResist(WeaponObject::BLAST))
prototype->setSpecialResist(WeaponObject::BLAST);
if (deed->isSpecialResist(WeaponObject::HEAT))
prototype->setSpecialResist(WeaponObject::HEAT);
if (deed->isSpecialResist(WeaponObject::COLD))
prototype->setSpecialResist(WeaponObject::COLD);
if (deed->isSpecialResist(WeaponObject::ELECTRICITY))
prototype->setSpecialResist(WeaponObject::ELECTRICITY);
if (deed->isSpecialResist(WeaponObject::ACID))
prototype->setSpecialResist(WeaponObject::ACID);
if (deed->isSpecialResist(WeaponObject::LIGHTSABER))
prototype->setSpecialResist(WeaponObject::LIGHTSABER);
Locker locker(inventory);
if (inventory->transferObject(prototype, -1, true, false)) {
inventory->broadcastObject(prototype, true);
} else {
prototype->destroyObjectFromDatabase(true);
}
}
void DnaManager::generateSample(Creature* creature, CreatureObject* player,int quality){
if (quality < 0 || quality > 7) {
return;
}
Locker lock(creature,player);
CreatureTemplate* creatureTemplate = dynamic_cast<CreatureTemplate*>(creature->getCreatureTemplate());
int ferocity = creatureTemplate->getFerocity();
int cl = creature->getLevel();
int cle = Genetics::hitChanceToValue(creature->getChanceHit(),quality);
int cou = Genetics::meatTypeToValue(creature->getMeatType(),quality);
int dep = Genetics::dietToValue(creature->getDiet(),quality);
int dex = Genetics::hamToValue(creature->getMaxHAM(3),quality);
int end = Genetics::accelerationToValue(creature->getWalkAcceleration(),quality);
int fie = Genetics::ferocityToValue(ferocity,quality);
int frt = Genetics::resistanceToValue(creature->getEffectiveResist(),creature->getArmor(),quality);
int har = Genetics::hamToValue(creature->getMaxHAM(0),quality);
int ite = Genetics::hamToValue(creature->getMaxHAM(6),quality);
int pow = Genetics::damageToValue((creature->getDamageMax() + creature->getDamageMin())/2,quality);
ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
if (inventory->hasFullContainerObjects()) {
StringIdChatParameter err("survey", "no_inv_space");
player->sendSystemMessage(err);
player->setPosture(CreaturePosture::UPRIGHT, true);
return;
}
// We should now have enough to generate a sample
ManagedReference<DnaComponent*> prototype = player->getZoneServer()->createObject(qualityTemplates.get(quality), 1).castTo<DnaComponent*>();
if (prototype == NULL) {
return;
}
Locker clocker(prototype);
// Check Here for unique npcs
StringId* nameId = creature->getObjectName();
if (nameId->getFile().isEmpty() || nameId->getStringID().isEmpty()) {
prototype->setSource(creature->getCreatureName().toString());
} else {
prototype->setSource(nameId->getFullPath());
}
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(creatureTemplate->getStun());
prototype->setKinetic(creatureTemplate->getKinetic());
prototype->setEnergy(creatureTemplate->getEnergy());
prototype->setBlast(creatureTemplate->getBlast());
prototype->setHeat(creatureTemplate->getHeat());
prototype->setCold(creatureTemplate->getCold());
prototype->setElectric(creatureTemplate->getElectricity());
prototype->setAcid(creatureTemplate->getAcid());
prototype->setSaber(creatureTemplate->getLightSaber());
prototype->setRanged(creatureTemplate->getWeapons().size() > 0);
prototype->setArmorRating(creatureTemplate->getArmor());
if (creatureTemplate->isSpecialProtection(WeaponObject::STUN))
prototype->setSpecialResist(WeaponObject::STUN);
if (creatureTemplate->isSpecialProtection(WeaponObject::KINETIC))
prototype->setSpecialResist(WeaponObject::KINETIC);
if (creatureTemplate->isSpecialProtection(WeaponObject::ENERGY))
prototype->setSpecialResist(WeaponObject::ENERGY);
if (creatureTemplate->isSpecialProtection(WeaponObject::BLAST))
prototype->setSpecialResist(WeaponObject::BLAST);
if (creatureTemplate->isSpecialProtection(WeaponObject::HEAT))
prototype->setSpecialResist(WeaponObject::HEAT);
if (creatureTemplate->isSpecialProtection(WeaponObject::COLD))
prototype->setSpecialResist(WeaponObject::COLD);
if (creatureTemplate->isSpecialProtection(WeaponObject::ELECTRICITY))
prototype->setSpecialResist(WeaponObject::ELECTRICITY);
if (creatureTemplate->isSpecialProtection(WeaponObject::ACID))
prototype->setSpecialResist(WeaponObject::ACID);
if (creatureTemplate->isSpecialProtection(WeaponObject::LIGHTSABER))
prototype->setSpecialResist(WeaponObject::LIGHTSABER);
CreatureAttackMap* attackMap = creatureTemplate->getAttacks();
if (attackMap->size() > 0) {
prototype->setSpecialAttackOne(String(attackMap->getCommand(0)));
if(attackMap->size() > 1) {
prototype->setSpecialAttackTwo(String(attackMap->getCommand(1)));
}
}
Locker locker(inventory);
if (inventory->transferObject(prototype, -1, true, false)) {
inventory->broadcastObject(prototype, true);
} else {
prototype->destroyObjectFromDatabase(true);
}
}