CreatureObject* ThreatMap::getHighestDamagePlayer() {
Locker locker(&lockMutex);
uint32 maxDamage = 0;
VectorMap<uint64,uint32> damageMap;
CreatureObject* player = NULL;
for (int i = 0; i < size(); ++i) {
ThreatMapEntry* entry = &elementAt(i).getValue();
uint32 totalDamage = 0;
for (int j = 0; j < entry->size(); ++j) {
uint32 damage = entry->elementAt(j).getValue();
totalDamage += damage;
}
CreatureObject* creature = elementAt(i).getKey();
if (creature->isPlayerCreature()) {
if(!damageMap.contains(creature->getObjectID())){
damageMap.put(creature->getObjectID(),totalDamage);
} else {
damageMap.get(creature->getObjectID()) += totalDamage;
}
if (damageMap.get(creature->getObjectID()) > maxDamage) {
maxDamage = damageMap.get(creature->getObjectID());
player = cast<CreatureObject*>(creature);
}
} else if (creature->isPet()) {
CreatureObject* owner = creature->getLinkedCreature().get();
if (owner != NULL && owner->isPlayerCreature()) {
if(!damageMap.contains(owner->getObjectID())){
damageMap.put(owner->getObjectID(),totalDamage);
} else {
damageMap.get(owner->getObjectID()) += totalDamage;
}
if (damageMap.get(owner->getObjectID()) > maxDamage) {
maxDamage = damageMap.get(owner->getObjectID());
player = cast<CreatureObject*>(owner);
}
}
}
}
return player;
}
void CraftingSessionImplementation::addSkillMods() {
ManagedReference<ManufactureSchematic*> manufactureSchematic = this->manufactureSchematic.get();
ManagedReference<TangibleObject*> prototype = this->prototype.get();
ManagedReference<DraftSchematic*> draftSchematic = manufactureSchematic->getDraftSchematic();
VectorMap<String, int>* skillMods = draftSchematic->getDraftSchematicTemplate()->getSkillMods();
for (int i = 0; i < skillMods->size(); i++) {
VectorMapEntry<String, int> mod = skillMods->elementAt(i);
if (prototype->isWearableObject()) {
WearableObject* wearable = prototype.castTo<WearableObject*>();
VectorMap<String, int>* wearableMods = wearable->getWearableSkillMods();
if (wearableMods->contains(mod.getKey())) {
int oldValue = wearableMods->get(mod.getKey());
int newValue = mod.getValue() + oldValue;
if (newValue > 25)
newValue = 25;
wearableMods->put(mod.getKey(), newValue);
continue;
}
}
prototype->addSkillMod(SkillModManager::WEARABLE, mod.getKey(), mod.getValue(), false);
}
}
void SkillManager::updateXpLimits(PlayerObject* ghost) {
if (ghost == NULL || !ghost->isPlayerObject()) {
return;
}
VectorMap<String, int>* xpTypeCapList = ghost->getXpTypeCapList();
//Clear all xp limits to the default limits.
for (int i = 0; i < defaultXpLimits.size(); ++i) {
String xpType = defaultXpLimits.elementAt(i).getKey();
int xpLimit = defaultXpLimits.elementAt(i).getValue();
if (xpTypeCapList->contains(xpType)) {
xpTypeCapList->get(xpType) = xpLimit;
} else {
xpTypeCapList->put(xpType, xpLimit);
}
}
//Iterate over the player skills and update xp limits accordingly.
ManagedReference<CreatureObject*> player = cast<CreatureObject*>(ghost->getParentRecursively(SceneObjectType::PLAYERCREATURE).get().get());
if(player == NULL)
return;
SkillList* playerSkillBoxList = player->getSkillList();
for(int i = 0; i < playerSkillBoxList->size(); ++i) {
Skill* skillBox = playerSkillBoxList->get(i);
if (skillBox == NULL)
continue;
if (xpTypeCapList->contains(skillBox->getXpType()) && (xpTypeCapList->get(skillBox->getXpType()) < skillBox->getXpCap())) {
xpTypeCapList->get(skillBox->getXpType()) = skillBox->getXpCap();
}
}
//Iterate over the player xp types and cap all xp types to the limits.
DeltaVectorMap<String, int>* experienceList = ghost->getExperienceList();
for (int i = 0; i < experienceList->size(); ++i) {
String xpType = experienceList->getKeyAt(i);
if (experienceList->get(xpType) > xpTypeCapList->get(xpType)) {
ghost->addExperience(xpType, xpTypeCapList->get(xpType) - experienceList->get(xpType), true);
}
}
}
CreatureObject* ThreatMap::getHighestDamageGroupLeader() {
Locker locker(&lockMutex);
VectorMap<uint64,uint32> groupDamageMap;
int64 highestGroupDmg = 0;
//Logger::Logger tlog("Threat");
ManagedReference<CreatureObject*> leaderCreature = NULL;
for (int i = 0; i < size(); ++i) {
ThreatMapEntry* entry = &elementAt(i).getValue();
uint32 totalDamage = entry->getTotalDamage();
CreatureObject* creature = elementAt(i).getKey();
//tlog.info("Group id is " + String::valueOf(creature->getGroupID()),true);
if (creature->isGrouped()) {
Reference<CreatureObject*> thisleader = creature->getGroup()->getLeader();
//tlog.info("leader is " + thisleader->getFirstName(),true);
if (thisleader == NULL || !thisleader->isPlayerCreature())
break;
if (!groupDamageMap.contains(creature->getGroupID())) {
//tlog.info("first dmg for group " + String::valueOf(creature->getGroupID()) + " dmg: " + String::valueOf(totalDamage), true);
groupDamageMap.put(creature->getGroupID(),totalDamage);
} else {
groupDamageMap.get(creature->getGroupID()) += totalDamage;
//tlog.info("adding to group " + String::valueOf(creature->getGroupID()) + " dmg total: " + String::valueOf(groupDamageMap.get(creature->getGroupID())) + " this player dmg: " + String::valueOf(totalDamage),true);
}
if (groupDamageMap.get(creature->getGroupID()) > highestGroupDmg) {
highestGroupDmg = groupDamageMap.get(creature->getGroupID());
leaderCreature = thisleader;
}
} else if (creature->isPet()) {
CreatureObject* owner = creature->getLinkedCreature().get();
if (owner != NULL && owner->isPlayerCreature()) {
if (owner->isGrouped()) {
Reference<CreatureObject*> thisleader = owner->getGroup()->getLeader();
if (thisleader == NULL || !thisleader->isPlayerCreature())
break;
if (!groupDamageMap.contains(owner->getGroupID())) {
groupDamageMap.put(owner->getGroupID(),totalDamage);
} else {
groupDamageMap.get(owner->getGroupID()) += totalDamage;
}
if (groupDamageMap.get(owner->getGroupID()) > highestGroupDmg) {
highestGroupDmg = groupDamageMap.get(owner->getGroupID());
leaderCreature = thisleader;
}
} else {
if (!groupDamageMap.contains(owner->getObjectID())) {
groupDamageMap.put(owner->getObjectID(),totalDamage);
} else {
groupDamageMap.get(owner->getObjectID()) += totalDamage;
}
if (totalDamage > highestGroupDmg) {
highestGroupDmg = totalDamage;
leaderCreature = owner;
}
}
}
} else {
//tlog.info("adding single creature damage " + String::valueOf(totalDamage),true);
groupDamageMap.put(creature->getObjectID(),totalDamage);
if (totalDamage > highestGroupDmg) {
highestGroupDmg = totalDamage;
leaderCreature = creature;
}
}
}
//tlog.info("highest group is " + leaderCreature->getFirstName() + " damage of " + String::valueOf(highestGroupDmg),true);
return leaderCreature;
}
void DraftSchematicObjectTemplate::readObject(LuaObject* templateData) {
SharedDraftSchematicObjectTemplate::readObject(templateData);
customObjectName = templateData->getStringField("customObjectName");
craftingToolTab = templateData->getIntField("craftingToolTab");
complexity = templateData->getShortField("complexity");
size = templateData->getShortField("size");
xpType = templateData->getStringField("xpType");
xp = templateData->getIntField("xp");
labratory = templateData->getIntField("lab");
disableFactory = templateData->getBooleanField("disableFactoryRun");
assemblySkill = templateData->getStringField("assemblySkill");
experimentingSkill = templateData->getStringField("experimentingSkill");
customizationSkill = templateData->getStringField("customizationSkill");
LuaObject ingredientTemplateNamesList = templateData->getObjectField(
"ingredientTemplateNames");
for (int i = 1; i <= ingredientTemplateNamesList.getTableSize(); ++i) {
ingredientTemplateNames->add(ingredientTemplateNamesList.getStringAt(i));
}
ingredientTemplateNamesList.pop();
LuaObject ingredientTitleNamesList = templateData->getObjectField(
"ingredientTitleNames");
for (int i = 1; i <= ingredientTitleNamesList.getTableSize(); ++i) {
ingredientTitleNames->add(ingredientTitleNamesList.getStringAt(i));
}
ingredientTitleNamesList.pop();
LuaObject ingredientSlotTypeList = templateData->getObjectField(
"ingredientSlotType");
for (int i = 1; i <= ingredientSlotTypeList.getTableSize(); ++i) {
ingredientSlotType->add(ingredientSlotTypeList.getIntAt(i));
}
ingredientSlotTypeList.pop();
LuaObject ingredientAppearanceList = templateData->getObjectField("ingredientAppearance");
if (ingredientAppearanceList.isValidTable()) {
for (int i = 1; i <= ingredientAppearanceList.getTableSize(); i++)
ingredientAppearance->add(ingredientAppearanceList.getStringAt(i));
} else {
for (int i = 0; i < ingredientTitleNames->size(); i++)
ingredientAppearance->add("");
}
ingredientAppearanceList.pop();
LuaObject resourceTypesList = templateData->getObjectField("resourceTypes");
for (int i = 1; i <= resourceTypesList.getTableSize(); ++i) {
resourceTypes->add(resourceTypesList.getStringAt(i));
}
resourceTypesList.pop();
LuaObject resourceQuantitiesList = templateData->getObjectField(
"resourceQuantities");
for (int i = 1; i <= resourceQuantitiesList.getTableSize(); ++i) {
resourceQuantities->add(resourceQuantitiesList.getIntAt(i));
}
resourceQuantitiesList.pop();
LuaObject contributionList = templateData->getObjectField("contribution");
for (int i = 1; i <= contributionList.getTableSize(); ++i) {
contribution->add(contributionList.getIntAt(i));
}
contributionList.pop();
for (int i = 0; i < ingredientTemplateNames->size(); ++i) {
DraftSlot* newSlot = new DraftSlot();
newSlot->setStringId(ingredientTemplateNames->get(i),
ingredientTitleNames->get(i));
newSlot->setSlotType(ingredientSlotType->get(i));
newSlot->setResourceType(resourceTypes->get(i));
newSlot->setQuantity(resourceQuantities->get(i));
newSlot->setContribution(contribution->get(i));
addSlot(newSlot);
}
tanoCRC = templateData->getStringField("targetTemplate").hashCode();
LuaObject availableTemplateList = templateData->getObjectField(
"additionalTemplates");
for (int i = 1; i <= availableTemplateList.getTableSize(); ++i) {
additionalTemplates->add(availableTemplateList.getStringAt(i));
}
contributionList.pop();
LuaObject skillModList = templateData->getObjectField("skillMods");
for (int i = 1; i <= skillModList.getTableSize(); ++i) {
LuaObject mod = skillModList.getObjectAt(i);
String modName = mod.getStringAt(1);
int modValue = mod.getIntAt(2);
skillMods.put(modName, modValue);
mod.pop();
}
skillModList.pop();
LuaObject weaponDotList = templateData->getObjectField("weaponDots");
for (int i = 1; i <= weaponDotList.getTableSize(); ++i) {
LuaObject dot = weaponDotList.getObjectAt(i);
VectorMap<String, int> dotValues;
for (int j = 1; j <= dot.getTableSize(); ++j) {
LuaObject attribute = dot.getObjectAt(j);
String attrName = attribute.getStringAt(1);
int attrValue = attribute.getIntAt(2);
dotValues.put(attrName, attrValue);
attribute.pop();
}
weaponDots.add(dotValues);
dot.pop();
}
weaponDotList.pop();
}
bool LairObserverImplementation::checkForNewSpawns(TangibleObject* lair, TangibleObject* attacker, bool forceSpawn) {
if (lair->getZone() == NULL)
return false;
if (spawnedCreatures.size() >= lairTemplate->getSpawnLimit() && !lairTemplate->hasBossMobs())
return false;
if (forceSpawn) {
spawnNumber++;
} else if (getMobType() == LairTemplate::NPC) {
return false;
} else {
int conditionDamage = lair->getConditionDamage();
int maxCondition = lair->getMaxCondition();
switch (spawnNumber) {
case 0:
spawnNumber++;
break;
case 1:
if (conditionDamage > (maxCondition / 10)) {
spawnNumber++;
} else {
return false;
}
break;
case 2:
if (conditionDamage > (maxCondition / 2)) {
spawnNumber++;
} else {
return false;
}
break;
case 3:
if (lairTemplate->hasBossMobs() && conditionDamage > ((maxCondition * 9) / 10)) {
spawnNumber++;
} else {
return false;
}
break;
default:
return false;
break;
}
}
VectorMap<String, int> objectsToSpawn; // String mobileTemplate, int number to spawn
if (spawnNumber == 4) {
if (System::random(100) > 9)
return false;
VectorMap<String, int>* mobs = lairTemplate->getBossMobiles();
for (int i = 0; i < mobs->size(); i++) {
objectsToSpawn.put(mobs->elementAt(i).getKey(), mobs->elementAt(i).getValue());
}
} else {
Vector<String>* mobiles = lairTemplate->getWeightedMobiles();
int amountToSpawn = 0;
if (getMobType() == LairTemplate::CREATURE) {
amountToSpawn = System::random(3) + ((lairTemplate->getSpawnLimit() / 3) - 2);
} else {
amountToSpawn = System::random(lairTemplate->getSpawnLimit() / 2) + (lairTemplate->getSpawnLimit() / 2);
}
if (amountToSpawn < 1)
amountToSpawn = 1;
for (int i = 0; i < amountToSpawn; i++) {
int num = System::random(mobiles->size() - 1);
String mob = mobiles->get(num);
if (objectsToSpawn.contains(mob)) {
int value = objectsToSpawn.get(mob);
objectsToSpawn.drop(mob);
objectsToSpawn.put(mob, value + 1);
} else {
objectsToSpawn.put(mob, 1);
}
}
}
for(int i = 0; i < objectsToSpawn.size(); ++i) {
if (spawnNumber != 4 && spawnedCreatures.size() >= lairTemplate->getSpawnLimit())
return true;
String templateToSpawn = objectsToSpawn.elementAt(i).getKey();
int numberToSpawn = objectsToSpawn.get(templateToSpawn);
CreatureTemplate* creatureTemplate = CreatureTemplateManager::instance()->getTemplate(templateToSpawn);
if (creatureTemplate == NULL)
continue;
float tamingChance = creatureTemplate->getTame();
CreatureManager* creatureManager = lair->getZone()->getCreatureManager();
for (int j = 0; j < numberToSpawn; j++) {
float x = lair->getPositionX() + (size - System::random(size * 20) / 10.0f);
float y = lair->getPositionY() + (size - System::random(size * 20) / 10.0f);
float z = lair->getZone()->getHeight(x, y);
ManagedReference<CreatureObject*> creo = NULL;
if (creatureManager->checkSpawnAsBaby(tamingChance, babiesSpawned, 500)) {
creo = creatureManager->spawnCreatureAsBaby(templateToSpawn.hashCode(), x, z, y);
babiesSpawned++;
}
if (creo == NULL)
creo = creatureManager->spawnCreatureWithAi(templateToSpawn.hashCode(), x, z, y);
if (creo == NULL)
continue;
if (!creo->isAiAgent()) {
error("spawned non player creature with template " + templateToSpawn);
} else {
AiAgent* ai = cast<AiAgent*>( creo.get());
//Locker clocker(npc, lair);
ai->setDespawnOnNoPlayerInRange(false);
ai->setHomeLocation(x, z, y);
ai->setRespawnTimer(0);
ai->setHomeObject(lair);
spawnedCreatures.add(creo);
}
}
}
if (spawnNumber == 4) {
Reference<LairAggroTask*> task = new LairAggroTask(lair, attacker, _this.get(), true);
task->schedule(1000);
}
return objectsToSpawn.size() > 0;
}
SceneObject* ObjectManager::cloneObject(SceneObject* object, bool makeTransient) {
ObjectOutputStream objectData(500);
(cast<ManagedObject*>(object))->writeObject(&objectData);
objectData.reset();
ObjectInputStream objectInput;
objectData.copy(&objectInput, 0);
objectInput.reset();
uint32 serverCRC = object->getServerObjectCRC();
SceneObject* clonedObject = NULL;
ObjectDatabase* database = getTable(object->getObjectID());
String databaseName;
uint64 oid;
if (database != NULL) {
database->getDatabaseName(databaseName);
oid = getNextObjectID(databaseName);
} else
oid = getNextFreeObjectID();
clonedObject = instantiateSceneObject(serverCRC, oid, false);
if (makeTransient || !object->isPersistent()) {
//clonedObject = createObject(serverCRC, 0, databaseName);
clonedObject->setPersistent(0);
} else if (object->isPersistent()) {
//clonedObject = createObject(serverCRC, object->getPersistenceLevel(), databaseName);
clonedObject->setPersistent(object->getPersistenceLevel());
}
Locker locker(clonedObject);
clonedObject->readObject(&objectInput);
clonedObject->createComponents();
clonedObject->setParent(NULL);
VectorMap<String, ManagedReference<SceneObject*> > slottedObjects;
clonedObject->getSlottedObjects(slottedObjects);
for (int i=slottedObjects.size()-1; i>=0; i--) {
String key = slottedObjects.elementAt(i).getKey();
Reference<SceneObject*> obj = slottedObjects.elementAt(i).getValue();
clonedObject->removeSlottedObject(i);
Reference<SceneObject*> clonedChild = cloneObject(obj, makeTransient);
clonedChild->setParent(object);
slottedObjects.put(key, clonedChild);
}
VectorMap<uint64, ManagedReference<SceneObject*> > objects;
clonedObject->getContainerObjects(objects);
for (int i=objects.size()-1; i>=0; i--) {
uint64 key = objects.elementAt(i).getKey();
Reference<SceneObject*> obj = objects.elementAt(i).getValue();
objects.remove(i);
Reference<SceneObject*> clonedChild = cloneObject(obj, makeTransient);
clonedChild->setParent(object);
objects.put(key, clonedChild);
}
clonedObject->onCloneObject(object);
if (clonedObject->isPersistent())
updatePersistentObject(clonedObject);
return clonedObject;
}
void LootManagerImplementation::setSkillMods(TangibleObject* object, LootItemTemplate* templateObject, int level, float excMod) {
if (!object->isWeaponObject() && !object->isWearableObject())
return;
VectorMap<String, int>* skillMods = templateObject->getSkillMods();
VectorMap<String, int> additionalMods;
bool yellow = false;
if (System::random(skillModChance / excMod) == 0) {
// if it has a skillmod the name will be yellow
yellow = true;
int modCount = 1;
int roll = System::random(100);
if(roll > (100 - excMod))
modCount += 2;
if(roll < (5 * excMod))
modCount += 1;
for(int i = 0; i < modCount; ++i) {
//Mods can't be lower than -1 or greater than 25
int max = MAX(-1, MIN(25, round(0.1f * level + 3)));
int min = MAX(-1, MIN(25, round(0.075f * level - 1)));
int mod = System::random(max - min) + min;
if(mod == 0)
mod = 1;
String modName = getRandomLootableMod( object->getGameObjectType() );
if( !modName.isEmpty() )
additionalMods.put(modName, mod);
}
}
if (yellow) {
uint32 bitmask = object->getOptionsBitmask() | OptionBitmask::YELLOW;
object->setOptionsBitmask(bitmask, false);
}
if (object->isWearableObject()) {
ManagedReference<WearableObject*> wearableObject = cast<WearableObject*>(object);
for (int i = 0; i < additionalMods.size(); i++) {
wearableObject->addSkillMod(SkillModManager::WEARABLE, additionalMods.elementAt(i).getKey(), additionalMods.elementAt(i).getValue());
}
for (int i = 0; i < skillMods->size(); i++) {
wearableObject->addSkillMod(SkillModManager::WEARABLE, skillMods->elementAt(i).getKey(), skillMods->elementAt(i).getValue());
}
} else if (object->isWeaponObject()) {
ManagedReference<WeaponObject*> weaponObject = cast<WeaponObject*>(object);
for (int i = 0; i < additionalMods.size(); i++) {
weaponObject->addSkillMod(SkillModManager::WEARABLE, additionalMods.elementAt(i).getKey(), additionalMods.elementAt(i).getValue());
}
for (int i = 0; i < skillMods->size(); i++) {
weaponObject->addSkillMod(SkillModManager::WEARABLE, skillMods->elementAt(i).getKey(), skillMods->elementAt(i).getValue());
}
}
}
bool ContainerComponent::transferObject(SceneObject* sceneObject, SceneObject* object, int containmentType, bool notifyClient, bool allowOverflow) {
if (sceneObject == object) {
return false;
}
ManagedReference<SceneObject*> objParent = object->getParent();
ManagedReference<Zone*> objZone = object->getLocalZone();
if (object->containsActiveSession(SessionFacadeType::SLICING)) {
ManagedReference<Facade*> facade = object->getActiveSession(SessionFacadeType::SLICING);
ManagedReference<SlicingSession*> session = dynamic_cast<SlicingSession*>(facade.get());
if (session != NULL) {
session->cancelSession();
}
}
if (objParent != NULL || objZone != NULL) {
if (objParent != NULL)
objParent->removeObject(object, sceneObject, notifyClient);
if (object->getParent() != NULL) {
object->error("error removing from parent");
return false;
}
if (objZone != NULL)
objZone->remove(object);
object->setZone(NULL);
if (objParent == NULL)
objParent = objZone;
}
bool update = true;
VectorMap<String, ManagedReference<SceneObject*> >* slottedObjects = sceneObject->getSlottedObjects();
VectorMap<uint64, ManagedReference<SceneObject*> >* containerObjects = sceneObject->getContainerObjects();
//if (containerType == 1 || containerType == 5) {
if (containmentType >= 4) {
Locker contLocker(sceneObject->getContainerLock());
int arrangementGroup = containmentType - 4;
if (object->getArrangementDescriptorSize() > arrangementGroup) {
const Vector<String>* descriptors = object->getArrangementDescriptor(arrangementGroup);
for (int i = 0; i < descriptors->size(); ++i){
const String& childArrangement = descriptors->get(i);
if (slottedObjects->contains(childArrangement)) {
return false;
}
}
for (int i = 0; i < descriptors->size(); ++i) {
slottedObjects->put(descriptors->get(i), object);
}
} else {
return false;
}
object->setParent(sceneObject);
object->setContainmentType(containmentType);
} else if (containmentType == -1) { /* else if (containerType == 2 || containerType == 3) {*/
Locker contLocker(sceneObject->getContainerLock());
if (!allowOverflow && containerObjects->size() >= sceneObject->getContainerVolumeLimit()){
return false;
}
/*if (containerObjects.contains(object->getObjectID()))
return false*/
if (containerObjects->put(object->getObjectID(), object) == -1)
update = false;
object->setParent(sceneObject);
object->setContainmentType(containmentType);
} else {
sceneObject->error("unknown containment type " + String::valueOf(containmentType));
StackTrace::printStackTrace();
return false;
}
if ((containmentType >= 4) && objZone == NULL)
sceneObject->broadcastObject(object, true);
else if (notifyClient)
sceneObject->broadcastMessage(object->link(sceneObject->getObjectID(), containmentType), true);
notifyObjectInserted(sceneObject, object);
if (update) {
sceneObject->updateToDatabase();
//object->updateToDatabaseWithoutChildren()();
}
ManagedReference<SceneObject*> rootParent = object->getRootParent();
if (rootParent != NULL)
rootParent->notifyObjectInsertedToChild(object, sceneObject, objParent);
object->notifyObservers(ObserverEventType::PARENTCHANGED, sceneObject);
return true;
}