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; }