void ThreatMap::addDamage(CreatureObject* target, uint32 damage, String xp) {
Locker locker(&lockMutex);
ManagedReference<TangibleObject*> strongSelf = self.get();
if (strongSelf == NULL || strongSelf.get() == target)
return;
int idx = find(target);
String xpToAward = "";
if (xp == "") {
WeaponObject* weapon = target->getWeapon();
xpToAward = weapon->getXpType();
} else
xpToAward = xp;
if (idx == -1) {
ThreatMapEntry entry;
entry.addDamage(xpToAward, damage);
entry.addAggro(1);
put(target, entry);
registerObserver(target);
} else {
ThreatMapEntry* entry = &elementAt(idx).getValue();
entry->addDamage(xpToAward, damage);
entry->addAggro(1);
}
}
void ThreatMap::addDamage(CreatureObject* target, uint32 damage, String xp) {
Locker locker(&lockMutex);
int idx = find(target);
String xpToAward = "";
if (xp == "") {
WeaponObject* weapon = target->getWeapon();
xpToAward = weapon->getXpType();
} else
xpToAward = xp;
if (idx == -1) {
ThreatMapEntry entry;
entry.addDamage(xpToAward, damage);
entry.addAggro(1);
put(target, entry);
registerObserver(target);
} else {
ThreatMapEntry* entry = &elementAt(idx).getValue();
entry->addDamage(xpToAward, damage);
entry->addAggro(1);
}
// randomly change target everytime threatmap is added to, TODO: keep this in mind and perhaps make it slightly more complicated
if (System::random(5) == 0)
currentThreat = target;
}
/**
* Is called when this object has been inserted with an object
* @param object object that has been inserted
*/
int PlayerContainerComponent::notifyObjectInserted(SceneObject* sceneObject, SceneObject* object) const {
CreatureObject* creo = dynamic_cast<CreatureObject*>(sceneObject);
if (creo == NULL) {
return 0;
}
if (object->isArmorObject()) {
PlayerManager* playerManager = sceneObject->getZoneServer()->getPlayerManager();
playerManager->applyEncumbrancies(creo, cast<ArmorObject*>(object));
}
if (object->isTangibleObject()) {
TangibleObject* tano = cast<TangibleObject*>(object);
tano->applySkillModsTo(creo);
}
if (object->isInstrument() && creo->isEntertaining())
creo->stopEntertaining();
//this it to update the equipment list
//we need a DeltaVector with all the slotted objects it seems
/*CreatureObjectMessage6* msg6 = new CreatureObjectMessage6(creo);
creo->broadcastMessage(msg6, true, true);*/
if (object->isTangibleObject() && object->getArrangementDescriptorSize() != 0 && object->getArrangementDescriptor(0)->size() != 0) {
const String& arrangement = object->getArrangementDescriptor(0)->get(0);
if (arrangement != "mission_bag" && arrangement != "ghost" && arrangement != "bank") {
creo->addWearableObject(object->asTangibleObject(), true);
}
}
if (object->isTangibleObject()) {
ManagedReference<TangibleObject*> tano = object->asTangibleObject();
tano->addTemplateSkillMods(creo);
}
// Jedi stuff below.
PlayerObject* ghost = creo->getPlayerObject();
if (ghost && ghost->isJedi()) {
if (object->isRobeObject()) {
ghost->recalculateForcePower();
} else if (object->isWeaponObject()) {
WeaponObject* weaponObject = cast<WeaponObject*>(object);
if (weaponObject->isJediWeapon()) {
VisibilityManager::instance()->increaseVisibility(creo, VisibilityManager::SABERVISMOD);
}
}
}
return ContainerComponent::notifyObjectInserted(sceneObject, object);
}
void SlicingSessionImplementation::handleSliceSpeed(uint8 percent) {
ManagedReference<CreatureObject*> player = this->player.get();
ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
if (tangibleObject == NULL || player == NULL || !tangibleObject->isWeaponObject())
return;
WeaponObject* weap = cast<WeaponObject*>( tangibleObject.get());
Locker locker(weap);
//TODO: Check for Weapon Powerups and Remove it before the Slice
weap->setSpeedSlice(percent / 100.f);
weap->setSliced(true);
StringIdChatParameter params;
params.setDI(percent);
params.setStringId("@slicing/slicing:spd_mod");
player->sendSystemMessage(params);
}
int PlayerContainerComponent::canAddObject(SceneObject* sceneObject, SceneObject* object, int containmentType, String& errorDescription) const {
CreatureObject* creo = dynamic_cast<CreatureObject*>(sceneObject);
if (creo == NULL) {
return TransferErrorCode::PLAYERUSEMASKERROR;
}
if (object->isTangibleObject() && containmentType == 4) {
TangibleObject* wearable = cast<TangibleObject*>(object);
SharedTangibleObjectTemplate* tanoData = dynamic_cast<SharedTangibleObjectTemplate*>(wearable->getObjectTemplate());
if (tanoData != NULL) {
Vector<uint32>* races = tanoData->getPlayerRaces();
String race = creo->getObjectTemplate()->getFullTemplateString();
if (!races->contains(race.hashCode())) {
errorDescription = "You lack the necessary requirements to wear this object";
return TransferErrorCode::PLAYERUSEMASKERROR;
}
}
if (creo->isPlayerCreature()) {
if (!wearable->isNeutral()) {
if (wearable->isImperial() && (creo->getFactionStatus() == FactionStatus::ONLEAVE || !creo->isImperial())) {
errorDescription = "You lack the necessary requirements to wear this object";
return TransferErrorCode::PLAYERUSEMASKERROR;
}
if (wearable->isRebel() && (creo->getFactionStatus() == FactionStatus::ONLEAVE || !creo->isRebel())) {
errorDescription = "You lack the necessary requirements to wear this object";
return TransferErrorCode::PLAYERUSEMASKERROR;
}
}
}
if (object->isArmorObject()) {
PlayerManager* playerManager = sceneObject->getZoneServer()->getPlayerManager();
if (!playerManager->checkEncumbrancies(creo, cast<ArmorObject*>(object))) {
errorDescription = "You lack the necessary secondary stats to equip this item";
return TransferErrorCode::NOTENOUGHENCUMBRANCE;
}
}
if (object->isWearableObject()) {
if (tanoData != NULL) {
const Vector<String>& skillsRequired = tanoData->getCertificationsRequired();
if (skillsRequired.size() > 0) {
bool hasSkill = false;
for (int i = 0; i < skillsRequired.size(); i++) {
const String& skill = skillsRequired.get(i);
if (!skill.isEmpty() && creo->hasSkill(skill)) {
hasSkill = true;
break;
}
}
if (!hasSkill) {
errorDescription = "@error_message:insufficient_skill"; // You lack the skill to use this item.
return TransferErrorCode::PLAYERUSEMASKERROR;
}
}
}
}
if (object->isWeaponObject()) {
WeaponObject* weapon = cast<WeaponObject*>(object);
int bladeColor = weapon->getBladeColor();
PlayerObject* ghost = creo->getPlayerObject();
if (weapon->isJediWeapon()) {
if (bladeColor == 31) {
errorDescription = "@jedi_spam:lightsaber_no_color";
return TransferErrorCode::PLAYERUSEMASKERROR;
}
if (weapon->getCraftersName() != creo->getFirstName() && !ghost->isPrivileged()) {
errorDescription = "@jedi_spam:not_your_lightsaber";
return TransferErrorCode::PLAYERUSEMASKERROR;
}
}
}
}
return ContainerComponent::canAddObject(sceneObject, object, containmentType, errorDescription);
}
int DroidDeedImplementation::handleObjectMenuSelect(CreatureObject* player, byte selectedID) {
if (selectedID == 20) {
if (generated || !isASubChildOf(player))
return 1;
if (player->isInCombat() || player->isRidingMount() || player->isSwimming() || player->isDead() || player->isIncapacitated() ){
player->sendSystemMessage("@pet/pet_menu:cant_call"); // "You cannot call this pet right now."
return 1;
}
ManagedReference<SceneObject*> datapad = player->getSlottedObject("datapad");
if (datapad == NULL) {
player->sendSystemMessage("Datapad doesn't exist when trying to generate droid");
return 1;
}
// Check if this will exceed maximum number of droids allowed
ManagedReference<PlayerManager*> playerManager = player->getZoneServer()->getPlayerManager();
int droidsInDatapad = 0;
int maxStoredDroids = playerManager->getBaseStoredDroids();
for (int i = 0; i < datapad->getContainerObjectsSize(); i++) {
Reference<SceneObject*> obj = datapad->getContainerObject(i).castTo<SceneObject*>();
if (obj != NULL && obj->isPetControlDevice() ){
Reference<PetControlDevice*> petDevice = cast<PetControlDevice*>(obj.get());
if( petDevice != NULL && petDevice->getPetType() == PetManager::DROIDPET){
droidsInDatapad++;
}
}
}
if( droidsInDatapad >= maxStoredDroids){
player->sendSystemMessage("You have too many droids in your datapad");
return 1;
}
Reference<CreatureManager*> creatureManager = player->getZone()->getCreatureManager();
if( creatureManager == NULL )
return 1;
CreatureTemplateManager* creatureTemplateManager = CreatureTemplateManager::instance();
Reference<CreatureTemplate*> creatureTemplate = creatureTemplateManager->getTemplate( mobileTemplate.hashCode() );
if( creatureTemplate == NULL ){
player->sendSystemMessage("wrong droid template;mobileTemplate=[" + mobileTemplate + "]" );
return 1;
}
Reference<PetControlDevice*> controlDevice = (server->getZoneServer()->createObject(controlDeviceObjectTemplate.hashCode(), 1)).castTo<PetControlDevice*>();
if( controlDevice == NULL ){
player->sendSystemMessage("wrong droid control device template " + controlDeviceObjectTemplate);
return 1;
}
Locker locker(controlDevice);
Reference<CreatureObject*> creatureObject = creatureManager->createCreature(generatedObjectTemplate.hashCode(), true, mobileTemplate.hashCode() );
if( creatureObject == NULL ){
controlDevice->destroyObjectFromDatabase(true);
player->sendSystemMessage("wrong droid templates;mobileTemplate=[" + mobileTemplate + "];generatedObjectTemplate=[" + generatedObjectTemplate + "]" );
return 1;
}
Locker clocker(creatureObject, player);
Reference<DroidObject*> droid = creatureObject.castTo<DroidObject*>();
if( droid == NULL ) {
controlDevice->destroyObjectFromDatabase(true);
creatureObject->destroyObjectFromDatabase(true);
return 1;
}
droid->loadTemplateData( creatureTemplate );
droid->setCustomObjectName(StringIdManager::instance()->getStringId(*droid->getObjectName()), true);
droid->createChildObjects();
droid->setControlDevice(controlDevice);
float maxHam = DroidMechanics::determineHam(overallQuality,species);
for (int i = 0; i < 9; ++i) {
if (i % 3 == 0) {
droid->setBaseHAM(i,maxHam,false);
droid->setHAM(i,maxHam,false);
droid->setMaxHAM(i,maxHam,false);
} else {
droid->setBaseHAM(i,maxHam/10,false);
droid->setHAM(i,maxHam/10,false);
droid->setMaxHAM(i,maxHam/10,false);
}
}
// Transfer crafting components from deed to droid
ManagedReference<SceneObject*> craftingComponents = getSlottedObject("crafted_components");
if(craftingComponents != NULL) {
SceneObject* satchel = craftingComponents->getContainerObject(0);
// remove all items form satchel and add int he new items
Vector<ManagedReference<SceneObject*> > toRemove;
for (int i = 0; i < satchel->getContainerObjectsSize(); ++i) {
ManagedReference<SceneObject*> sceno = satchel->getContainerObject(i);
if (sceno != NULL) {
toRemove.add(sceno);
}
}
satchel->removeAllContainerObjects();
for(int i=0;i<toRemove.size();i++) {
SceneObject* component = toRemove.get(i);
Locker componenetLocker(component);
component->destroyObjectFromWorld(true);
}
// this will change to use stacked modules. we wont care about non droid modules as they arent needed.
String key;
ManagedReference<DroidComponent*> comp = NULL;
HashTableIterator<String, ManagedReference<DroidComponent*> > iterator = modules.iterator();
for(int i = 0; i < modules.size(); ++i) {
iterator.getNextKeyAndValue(key, comp);
if (comp) {
satchel->transferObject(comp, -1, false);
DataObjectComponentReference* data = comp->getDataObjectComponent();
BaseDroidModuleComponent* module = NULL;
if(data != NULL && data->get() != NULL && data->get()->isDroidModuleData()) {
module = cast<BaseDroidModuleComponent*>(data->get());
module->initialize(droid);
}
}
}
droid->transferObject(craftingComponents, 4, false);
craftingComponents->setSendToClient(false);
}
droid->initDroidModules();
//Set weapon stats
WeaponObject* weapon = droid->getSlottedObject("default_weapon").castTo<WeaponObject*>();
if (weapon != NULL) {
Locker locker(weapon);
weapon->setMinDamage(droid->getDamageMin());
weapon->setMaxDamage(droid->getDamageMax());
weapon->setAttackSpeed(droid->getAttackSpeed());
}
// Copy color customization from deed to droid
CustomizationVariables* customVars = getCustomizationVariables();
if( customVars != NULL ){
for (int i = 0; i < customVars->size(); ++i) {
uint8 id = customVars->elementAt(i).getKey();
int16 val = customVars->elementAt(i).getValue();
String name = CustomizationIdManager::instance()->getCustomizationVariable(id);
if( name.contains( "color" ) ){
droid->setCustomizationVariable( name, val, true );
}
}
droid->refreshPaint();
}
StringId s;
s.setStringId(droid->getObjectName()->getFullPath());
controlDevice->setObjectName(s, false);
controlDevice->setPetType(PetManager::DROIDPET);
controlDevice->setMaxVitality(100);
controlDevice->setVitality(100);
controlDevice->setControlledObject(droid);
controlDevice->setDefaultCommands();
if (!datapad->transferObject(controlDevice, -1)) {
controlDevice->destroyObjectFromDatabase(true);
return 1;
}
datapad->broadcastObject(controlDevice, true);
controlDevice->callObject(player);
//Remove the deed from its container.
ManagedReference<SceneObject*> deedContainer = getParent().get();
if (deedContainer != NULL) {
destroyObjectFromWorld(true);
}
generated = true;
destroyObjectFromDatabase(true);
player->sendSystemMessage("@pet/pet_menu:device_added"); // "A control device has been added to your datapad."
return 0;
}
return DeedImplementation::handleObjectMenuSelect(player, selectedID);
}
