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);
}
}
}
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);
}
}
bool ImageDesignManager::validateCustomizationString(CustomizationVariables* data, const String& appearanceFilename, int skillLevel) {
VectorMap<String, Reference<CustomizationVariable*> > variables;
variables.setNullValue(NULL);
AssetCustomizationManagerTemplate::instance()->getCustomizationVariables(appearanceFilename.hashCode(), variables, false);
if (variables.size() == 0) {
instance()->error("no customization data found for " + appearanceFilename);
return false;
}
for (int i = 0; i < data->size(); ++i) {
uint8 id = data->elementAt(i).getKey();
int16 val = data->elementAt(i).getValue();
String name = CustomizationIdManager::instance()->getCustomizationVariable(id);
//instance()->info("validating " + name + " with value " + String::valueOf(val), true);
CustomizationVariable* customizationVariable = variables.get(name).get();
if (customizationVariable == NULL) {
instance()->error("customization variable id " + String::valueOf(id) + " not found in the appearance file " + appearanceFilename + " with value " + String::valueOf(val));
continue;
}
PaletteColorCustomizationVariable* palette = dynamic_cast<PaletteColorCustomizationVariable*>(customizationVariable);
if (palette != NULL) {
if (!validatePalette(palette, val, skillLevel))
return false;
} else {
BasicRangedIntCustomizationVariable* range = dynamic_cast<BasicRangedIntCustomizationVariable*>(customizationVariable);
if (range == NULL) {
instance()->error("unkown customization variable type " + name);
return false;
} else {
int maxExcl = range->getMaxValueExclusive();
int minIncl = range->getMinValueInclusive();
if (val >= maxExcl || val < minIncl) {
instance()->error("variable outside bounds " + name + " value " + val + " outside bounds [" + String::valueOf(minIncl) + "," + String::valueOf(maxExcl) + ")");
return false;
} else {
//instance()->info("variable " + name + " value " + String::valueOf(val) + " inside bounds [" + String::valueOf(minIncl) + "," + String::valueOf(maxExcl) + ")", true);
}
}
}
//info("setting variable:" + name + " to " + String::valueOf(val), true);
}
return true;
}
void SceneObjectImplementation::sendContainerObjectsTo(SceneObject* player) {
//sending all objects by default
VectorMap<uint64, ManagedReference<SceneObject* > > objects;
getContainerObjects(objects);
for (int j = 0; j < objects.size(); ++j) {
SceneObject* containerObject = objects.get(j);
if (containerObject == NULL)
continue;
if (containerObject->isInQuadTree()) {
notifyInsert(containerObject);
} else {
containerObject->sendTo(player, true);
}
}
}
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 SceneObjectImplementation::sendSlottedObjectsTo(SceneObject* player) {
//sending all slotted objects by default
VectorMap<String, ManagedReference<SceneObject* > > slotted;
getSlottedObjects(slotted);
SortedVector<SceneObject*> objects(slotted.size(), slotted.size());
objects.setNoDuplicateInsertPlan();
for (int i = 0; i < slotted.size(); ++i) {
SceneObject* object = slotted.get(i);
if (objects.put(object) != -1) {
if (object->isInQuadTree()) {
notifyInsert(object);
} else {
object->sendTo(player, 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;
}
bool ResourceLabratory::applyComponentStats(TangibleObject* prototype, ManufactureSchematic* manufactureSchematic) {
if(manufactureSchematic == NULL || manufactureSchematic->getDraftSchematic() == NULL)
return false;
float max, min, currentvalue, propertyvalue;
int precision;
bool modified = false;
bool hidden;
String experimentalTitle, property;
CraftingValues* craftingValues = manufactureSchematic->getCraftingValues();
ManagedReference<DraftSchematic* > draftSchematic = manufactureSchematic->getDraftSchematic();
for (int i = 0; i < manufactureSchematic->getSlotCount(); ++i) {
Reference<IngredientSlot* > ingredientSlot = manufactureSchematic->getSlot(i);
Reference<DraftSlot* > draftSlot = draftSchematic->getDraftSlot(i);
if(ingredientSlot == NULL || !ingredientSlot->isComponentSlot() || !ingredientSlot->isFull())
continue;
ComponentSlot* compSlot = cast<ComponentSlot*>(ingredientSlot.get());
if(compSlot == NULL)
continue;
ManagedReference<TangibleObject*> tano = compSlot->getPrototype();
if (tano == NULL || !tano->isComponent())
continue;
ManagedReference<Component*> component = cast<Component*>( tano.get());
if (prototype->isWearableObject() && !prototype->isArmorObject()) {
if (component->getObjectTemplate()->getObjectName() == "@craft_clothing_ingredients_n:reinforced_fiber_panels" || component->getObjectTemplate()->getObjectName() == "@craft_clothing_ingredients_n:synthetic_cloth"){
for (int k = 0; k < component->getPropertyCount(); ++k) {
const String property = component->getProperty(k);
if (property == "" || property == "null") {
continue;
}
String key = checkBioSkillMods(property);
if (key == "") {
continue;
} else {
currentvalue = component->getAttributeValue(property);
precision = component->getAttributePrecision(property);
int preciseValue = Math::getPrecision(currentvalue, precision);
WearableObject* clothing = cast<WearableObject*>(prototype);
VectorMap<String, int>* clothingMods = clothing->getWearableSkillMods();
int existingValue = 0;
if(clothingMods->contains(key)) {
existingValue = clothingMods->get(key);
}
preciseValue += existingValue;
if (preciseValue > 25)
preciseValue = 25;
clothing->addSkillMod(SkillModManager::WEARABLE, key, preciseValue);
}
}
}
} else {
for (int j = 0; j < component->getPropertyCount(); ++j) {
property = component->getProperty(j); // charges
modified = true;
if (craftingValues->hasProperty(property)) {
max = craftingValues->getMaxValue(property);
min = craftingValues->getMinValue(property);
hidden = craftingValues->isHidden(property);
currentvalue = craftingValues->getCurrentValue(property);
propertyvalue = component->getAttributeValue(property) * draftSlot->getContribution();
short combineType = craftingValues->getCombineType(property);
switch(combineType) {
case CraftingManager::LINEARCOMBINE:
currentvalue += propertyvalue;
min += propertyvalue;
max += propertyvalue;
craftingValues->setMinValue(property, min);
craftingValues->setMaxValue(property, max);
craftingValues->setCurrentValue(property, currentvalue);
break;
case CraftingManager::PERCENTAGECOMBINE:
currentvalue += propertyvalue;
min += propertyvalue;
max += propertyvalue;
craftingValues->setMinValue(property, min);
craftingValues->setMaxValue(property, max);
craftingValues->setCurrentPercentage(property, currentvalue);
break;
case CraftingManager::BITSETCOMBINE:
currentvalue = (int)currentvalue | (int)propertyvalue;
craftingValues->setCurrentValue(property , currentvalue);
break;
case CraftingManager::OVERRIDECOMBINE:
// Do nothing because the values should override whatever is
// on the component
break;
default:
break;
}
} else {
currentvalue = component->getAttributeValue(property);
precision = component->getAttributePrecision(property);
experimentalTitle = component->getAttributeTitle(property);
craftingValues->addExperimentalProperty(experimentalTitle, property,
currentvalue, currentvalue, precision, component->getAttributeHidden(property), CraftingManager::LINEARCOMBINE);
craftingValues->setCurrentPercentage(property, 0);
craftingValues->setMaxPercentage(property, 0);
craftingValues->setCurrentValue(property, currentvalue);
}
}
}
}
return modified;
}
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;
}
bool ContainerComponent::removeObject(SceneObject* sceneObject, SceneObject* object, SceneObject* destination, bool notifyClient) {
VectorMap<String, ManagedReference<SceneObject*> >* slottedObjects = sceneObject->getSlottedObjects();
VectorMap<uint64, ManagedReference<SceneObject*> >* containerObjects = sceneObject->getContainerObjects();
ManagedReference<SceneObject*> objectKeeper = object;
if (object->getParent() != sceneObject && object->getParent() != NULL) {
ManagedReference<SceneObject*> objParent = object->getParent();
Locker contLocker(sceneObject->getContainerLock());
containerObjects->drop(object->getObjectID());
if (objParent->hasObjectInContainer(object->getObjectID()) || objParent->hasObjectInSlottedContainer(object)) {
sceneObject->error("trying to remove an object that is in a different object");
objParent->info("i am the parent", true);
return false;
} else
object->setParent(NULL);
}
int containedType = object->getContainmentType();
//info("trying to remove object with containedType " + String::valueOf(containedType), true);
// if (containedType == 4 || containedType == 5) {
Locker contLocker(sceneObject->getContainerLock());
int arrangementSize = object->getArrangementDescriptorSize();
int arrangementGroup = MAX(0, containedType - 4);
if (object->getArrangementDescriptorSize() > arrangementGroup) {
bool removeFromSlot = false;
const Vector<String>* descriptors = object->getArrangementDescriptor(arrangementGroup);
for (int i = 0; i < descriptors->size(); ++i){
const String& childArrangement = descriptors->get(i);
ManagedReference<SceneObject*> obj = slottedObjects->get(childArrangement);
if (slottedObjects->get(childArrangement) == object) {
removeFromSlot = true;
break;
}
}
if (removeFromSlot) {
for (int i = 0; i < descriptors->size(); ++i)
slottedObjects->drop(descriptors->get(i));
}
}
// } else if (containedType == -1) {
//Locker contLocker(sceneObject->getContainerLock());
if (containerObjects->contains(object->getObjectID())) {
//info("containerObjects doesnt contain specified object", true);
//object->setParent(NULL);
// return false;
containerObjects->drop(object->getObjectID());
}
object->setParent(NULL);
contLocker.release();
/*
} else {
sceneObject->error("unknown contained type " + String::valueOf(containedType));
StackTrace::printStackTrace();
return false;
}
*/
if (notifyClient)
sceneObject->broadcastMessage(object->link((uint64) 0, 0xFFFFFFFF), true);
notifyObjectRemoved(sceneObject, object, destination);
sceneObject->updateToDatabase();
object->updateToDatabase();
if (sceneObject->getParent() == NULL) {
sceneObject->notifyObjectRemovedFromChild(object, sceneObject);
} else {
ManagedReference<SceneObject*> rootParent = sceneObject->getRootParent();
if (rootParent != NULL)
rootParent->notifyObjectRemovedFromChild(object, sceneObject);
else
sceneObject->notifyObjectRemovedFromChild(object, sceneObject);
}
return true;
}
