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);
}
}
}
bool SkillManager::fullfillsSkillPrerequisitesAndXp(const String& skillName, CreatureObject* creature) {
if (!fullfillsSkillPrerequisites(skillName, creature)) {
return false;
}
Skill* skill = skillMap.get(skillName.hashCode());
if (skill == NULL) {
return false;
}
ManagedReference<PlayerObject* > ghost = creature->getPlayerObject();
if (ghost != NULL) {
//Check if player has enough xp to learn the skill.
if (skill->getXpCost() > 0 && ghost->getExperience(skill->getXpType()) < skill->getXpCost()) {
return false;
}
}
return true;
}
bool SkillManager::canLearnSkill(const String& skillName, CreatureObject* creature, bool noXpRequired) {
Skill* skill = skillMap.get(skillName.hashCode());
if (skill == NULL) {
return false;
}
//If they already have the skill, then return false.
if (creature->hasSkill(skillName)) {
return false;
}
if (!fullfillsSkillPrerequisites(skillName, creature)) {
return false;
}
ManagedReference<PlayerObject* > ghost = creature->getPlayerObject();
if (ghost != NULL) {
//Check if player has enough xp to learn the skill.
if (!noXpRequired) {
if (ghost->getExperience(skill->getXpType()) < skill->getXpCost()) {
return false;
}
}
//Check if player has enough skill points to learn the skill.
if (ghost->getSkillPoints() < skill->getSkillPointsRequired()) {
return false;
}
} else {
//Could not retrieve player object.
return false;
}
return true;
}
bool SkillManager::awardSkill(const String& skillName, CreatureObject* creature, bool notifyClient, bool awardRequiredSkills, bool noXpRequired) {
Skill* skill = skillMap.get(skillName.hashCode());
if (skill == NULL)
return false;
Locker locker(creature);
//Check for required skills.
Vector<String>* requiredSkills = skill->getSkillsRequired();
for (int i = 0; i < requiredSkills->size(); ++i) {
String requiredSkillName = requiredSkills->get(i);
Skill* requiredSkill = skillMap.get(requiredSkillName.hashCode());
if (requiredSkill == NULL)
continue;
if (awardRequiredSkills)
awardSkill(requiredSkillName, creature, notifyClient, awardRequiredSkills, noXpRequired);
if (!creature->hasSkill(requiredSkillName))
return false;
}
if (!canLearnSkill(skillName, creature, noXpRequired)) {
return false;
}
//If they already have the skill, then return true.
if (creature->hasSkill(skill->getSkillName()))
return true;
ManagedReference<PlayerObject*> ghost = creature->getPlayerObject();
if (ghost != NULL) {
//Withdraw skill points.
ghost->addSkillPoints(-skill->getSkillPointsRequired());
//Witdraw experience.
if (!noXpRequired) {
ghost->addExperience(skill->getXpType(), -skill->getXpCost(), true);
}
creature->addSkill(skill, notifyClient);
//Add skill modifiers
VectorMap<String, int>* skillModifiers = skill->getSkillModifiers();
for (int i = 0; i < skillModifiers->size(); ++i) {
VectorMapEntry<String, int>* entry = &skillModifiers->elementAt(i);
creature->addSkillMod(SkillModManager::SKILLBOX, entry->getKey(), entry->getValue(), notifyClient);
}
//Add abilities
Vector<String>* abilityNames = skill->getAbilities();
addAbilities(ghost, *abilityNames, notifyClient);
if (skill->isGodOnly()) {
for (int i = 0; i < abilityNames->size(); ++i) {
String ability = abilityNames->get(i);
StringIdChatParameter params;
params.setTU(ability);
params.setStringId("ui", "skill_command_acquired_prose");
creature->sendSystemMessage(params);
}
}
//Add draft schematic groups
Vector<String>* schematicsGranted = skill->getSchematicsGranted();
SchematicMap::instance()->addSchematics(ghost, *schematicsGranted, notifyClient);
//Update maximum experience.
updateXpLimits(ghost);
// Update Force Power Max.
ghost->setForcePowerMax(creature->getSkillMod("jedi_force_power_max"), true);
if (skillName.contains("master")) {
ManagedReference<PlayerManager*> playerManager = creature->getZoneServer()->getPlayerManager();
if (playerManager != NULL) {
const Badge* badge = BadgeList::instance()->get(skillName);
if (badge == NULL && skillName == "crafting_shipwright_master") {
badge = BadgeList::instance()->get("crafting_shipwright");
}
if (badge != NULL) {
playerManager->awardBadge(ghost, badge);
}
}
}
SkillList* list = creature->getSkillList();
int totalSkillPointsWasted = 250;
for (int i = 0; i < list->size(); ++i) {
Skill* skill = list->get(i);
totalSkillPointsWasted -= skill->getSkillPointsRequired();
}
if (ghost->getSkillPoints() != totalSkillPointsWasted) {
creature->error("skill points mismatch calculated: " + String::valueOf(totalSkillPointsWasted) + " found: " + String::valueOf(ghost->getSkillPoints()));
ghost->setSkillPoints(totalSkillPointsWasted);
}
ManagedReference<PlayerManager*> playerManager = creature->getZoneServer()->getPlayerManager();
if (playerManager != NULL) {
creature->setLevel(playerManager->calculatePlayerLevel(creature));
}
}
/// Update client with new values for things like Terrain Negotiation
CreatureObjectDeltaMessage4* msg4 = new CreatureObjectDeltaMessage4(creature);
msg4->updateAccelerationMultiplierBase();
msg4->updateAccelerationMultiplierMod();
msg4->updateSpeedMultiplierBase();
msg4->updateSpeedMultiplierMod();
msg4->updateRunSpeed();
msg4->updateTerrainNegotiation();
msg4->close();
creature->sendMessage(msg4);
SkillModManager::instance()->verifySkillBoxSkillMods(creature);
return true;
}