void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
WindowManager *wm = environment.mWindowManager;
// Add a line separator if there are items above
if (!skillWidgets.empty())
{
addSeparator(coord1, coord2);
}
addGroup(wm->getGameSettingString(titleId, titleDefault), coord1, coord2);
SkillList::const_iterator end = skills.end();
for (SkillList::const_iterator it = skills.begin(); it != end; ++it)
{
int skillId = *it;
if (skillId < 0 || skillId > ESM::Skill::Length) // Skip unknown skill indexes
continue;
assert(skillId >= 0 && skillId < ESM::Skill::Length);
const std::string &skillNameId = ESMS::Skill::sSkillNameIds[skillId];
const MWMechanics::Stat<float> &stat = skillValues.find(skillId)->second;
float base = stat.getBase();
float modified = stat.getModified();
ColorStyle style = CS_Normal;
if (modified > base)
style = CS_Super;
else if (modified < base)
style = CS_Sub;
MyGUI::StaticTextPtr widget = addValueItem(wm->getGameSettingString(skillNameId, skillNameId), boost::lexical_cast<std::string>(static_cast<int>(modified)), style, coord1, coord2);
skillWidgetMap[skillId] = widget;
}
}
bool SkillManager::knightPrereqsMet(CreatureObject* creature, const String& skillNameBeingDropped) {
SkillList* skillList = creature->getSkillList();
int fullTrees = 0;
int totalJediPoints = 0;
for(int i = 0; i < skillList->size(); ++i) {
Skill* skill = skillList->get(i);
String skillName = skill->getSkillName();
if(skillName.contains("force_discipline_") &&
(skillName.indexOf("0") != -1 || skillName.contains("novice") || skillName.contains("master") )) {
totalJediPoints += skill->getSkillPointsRequired();
if(skillName.indexOf("4") != -1) {
fullTrees++;
}
}
}
if(!skillNameBeingDropped.isEmpty()) {
Skill* skillBeingDropped = skillMap.get(skillNameBeingDropped.hashCode());
if(skillNameBeingDropped.indexOf("4") != -1) {
fullTrees--;
}
totalJediPoints -= skillBeingDropped->getSkillPointsRequired();
}
return fullTrees >= 2 && totalJediPoints >= 206;
}
void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
// Add a line separator if there are items above
if (!skillWidgets.empty())
{
addSeparator(coord1, coord2);
}
addGroup(mWindowManager.getGameSettingString(titleId, titleDefault), coord1, coord2);
SkillList::const_iterator end = skills.end();
for (SkillList::const_iterator it = skills.begin(); it != end; ++it)
{
int skillId = *it;
if (skillId < 0 || skillId > ESM::Skill::Length) // Skip unknown skill indexes
continue;
assert(skillId >= 0 && skillId < ESM::Skill::Length);
const std::string &skillNameId = ESMS::Skill::sSkillNameIds[skillId];
const MWMechanics::Stat<float> &stat = skillValues.find(skillId)->second;
float base = stat.getBase();
float modified = stat.getModified();
int progressPercent = (modified - float(static_cast<int>(modified))) * 100;
const ESM::Skill* skill = mWindowManager.getStore().skills.search(skillId);
assert(skill);
std::string icon = "icons\\k\\" + ESM::Skill::sIconNames[skillId];
const ESM::Attribute* attr = mWindowManager.getStore().attributes.search(skill->data.attribute);
assert(attr);
std::string state = "normal";
if (modified > base)
state = "increased";
else if (modified < base)
state = "decreased";
MyGUI::TextBox* widget = addValueItem(mWindowManager.getGameSettingString(skillNameId, skillNameId),
boost::lexical_cast<std::string>(static_cast<int>(modified)), state, coord1, coord2);
for (int i=0; i<2; ++i)
{
skillWidgets[skillWidgets.size()-1-i]->setUserString("ToolTipType", "Layout");
skillWidgets[skillWidgets.size()-1-i]->setUserString("ToolTipLayout", "SkillToolTip");
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_SkillName", "#{"+skillNameId+"}");
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_SkillDescription", skill->description);
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_SkillAttribute", "#{sGoverningAttribute}: #{" + attr->name + "}");
skillWidgets[skillWidgets.size()-1-i]->setUserString("ImageTexture_SkillImage", icon);
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_SkillProgressText", boost::lexical_cast<std::string>(progressPercent)+"/100");
skillWidgets[skillWidgets.size()-1-i]->setUserString("Range_SkillProgress", "100");
skillWidgets[skillWidgets.size()-1-i]->setUserString("RangePosition_SkillProgress", boost::lexical_cast<std::string>(progressPercent));
}
skillWidgetMap[skillId] = widget;
}
}
int SkillManager::getForceSensitiveSkillCount(CreatureObject* creature, bool includeNoviceMasterBoxes) {
SkillList* skills = creature->getSkillList();
int forceSensitiveSkillCount = 0;
for(int i = 0; i < skills->size(); ++i) {
String skillName = skills->get(i)->getSkillName();
if(skillName.contains("force_sensitive") && (includeNoviceMasterBoxes || skillName.indexOf("0") != -1)) {
forceSensitiveSkillCount++;
}
}
return forceSensitiveSkillCount;
}
void printSkillList(SkillList l)
{
SkillList::iterator itr(l.begin());
for(;itr != l.end(); itr++)
{
std::cout << itr->getName().toAnsiString() << std::endl;
std::cout << "Puissance : " << itr->getBasePower()
<< " Target : " << itr->needTarget()
<< " Target type : " << itr->getTargetType()
<< " CD : " << itr->getCooldown()
<< std::endl;
}
}
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 loadSkillList(SkillList& l)
{
std::ifstream file("rc/data/skilllist.csv");
std::string line;
std::string value;
std::string* listValue;
int index = 0;
while(std::getline(file, line))
{
Skill skill;
listValue = new std::string[6];
std::stringstream lineStream(line);
while(std::getline(lineStream, value, ','))
{
listValue[index] = value;
index++;
}
skill.setName(listValue[0]);
skill.setBasePower(atoi(listValue[1].c_str()));
skill.setTargetNeeded((atoi(listValue[2].c_str()) == 1) ? true : false);
skill.setTargetType(static_cast<TargetType>(atoi(listValue[3].c_str())));
skill.setCooldown(atoi(listValue[4].c_str()));
skill.setDescription(listValue[5]);
l.push_back(skill);
index = 0;
delete [] listValue;
}
}
void ObjectController::_handleSetCurrentSkillTitle(uint64 targetId,Message* message,ObjectControllerCmdProperties* cmdProperties)
{
PlayerObject* playerObject = dynamic_cast<PlayerObject*>(mObject);
BString newTitle;
message->getStringUnicode16(newTitle);
newTitle.convert(BSTRType_ANSI);
SkillList* sList = playerObject->getSkills();
SkillList::iterator sEnd = sList->end();
for(SkillList::iterator it=sList->begin(); it != sEnd; ++it)
{
if((*it)->mIsTitle)
{
if(strcmp((*it)->mName.getAnsi(),newTitle.getAnsi()) == 0)
{
playerObject->setTitle(newTitle.getAnsi());
gMessageLib->sendTitleUpdate(playerObject);
break;
}
}
}
}
void ReviewDialog::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
// Add a line separator if there are items above
if (!mSkillWidgets.empty())
{
addSeparator(coord1, coord2);
}
addGroup(mWindowManager.getGameSettingString(titleId, titleDefault), coord1, coord2);
SkillList::const_iterator end = skills.end();
for (SkillList::const_iterator it = skills.begin(); it != end; ++it)
{
int skillId = *it;
if (skillId < 0 || skillId > ESM::Skill::Length) // Skip unknown skill indexes
continue;
assert(skillId >= 0 && skillId < ESM::Skill::Length);
const std::string &skillNameId = ESM::Skill::sSkillNameIds[skillId];
const MWMechanics::Stat<float> &stat = mSkillValues.find(skillId)->second;
float base = stat.getBase();
float modified = stat.getModified();
std::string state = "normal";
if (modified > base)
state = "increased";
else if (modified < base)
state = "decreased";
MyGUI::TextBox* widget = addValueItem(mWindowManager.getGameSettingString(skillNameId, skillNameId), boost::lexical_cast<std::string>(static_cast<int>(modified)), state, coord1, coord2);
for (int i=0; i<2; ++i)
{
ToolTips::createSkillToolTip(mSkillWidgets[mSkillWidgets.size()-1-i], skillId);
}
mSkillWidgetMap[skillId] = widget;
}
}
void SkillManager::surrenderAllSkills(CreatureObject* creature, bool notifyClient) {
ManagedReference<PlayerObject*> ghost = creature->getPlayerObject();
SkillList* skillList = creature->getSkillList();
Vector<String> listOfNames;
skillList->getStringList(listOfNames);
SkillList copyOfList;
copyOfList.loadFromNames(listOfNames);
for (int i = 0; i < copyOfList.size(); i++) {
Skill* skill = copyOfList.get(i);
if (skill->getSkillPointsRequired() > 0) {
creature->removeSkill(skill, notifyClient);
//Remove skill modifiers
VectorMap<String, int>* skillModifiers = skill->getSkillModifiers();
for (int i = 0; i < skillModifiers->size(); ++i) {
VectorMapEntry<String, int>* entry = &skillModifiers->elementAt(i);
creature->removeSkillMod(SkillModManager::SKILLBOX, entry->getKey(), entry->getValue(), notifyClient);
}
SkillModManager::instance()->verifySkillBoxSkillMods(creature);
if (ghost != NULL) {
//Give the player the used skill points back.
ghost->addSkillPoints(skill->getSkillPointsRequired());
//Remove abilities
Vector<String>* abilityNames = skill->getAbilities();
removeAbilities(ghost, *abilityNames, notifyClient);
//Remove draft schematic groups
Vector<String>* schematicsGranted = skill->getSchematicsGranted();
SchematicMap::instance()->removeSchematics(ghost, *schematicsGranted, notifyClient);
/// update force
ghost->setForcePowerMax(creature->getSkillMod("jedi_force_power_max"), true);
}
}
}
}
bool SkillManager::surrenderSkill(const String& skillName, CreatureObject* creature, bool notifyClient) {
Skill* skill = skillMap.get(skillName.hashCode());
if (skill == NULL)
return false;
Locker locker(creature);
SkillList* skillList = creature->getSkillList();
if(skillName == "force_title_jedi_novice" && getForceSensitiveSkillCount(creature, true) > 0) {
return false;
}
if(skillName.beginsWith("force_sensitive_") &&
getForceSensitiveSkillCount(creature, false) <= 24 &&
creature->hasSkill("force_title_jedi_rank_01"))
return false;
for (int i = 0; i < skillList->size(); ++i) {
Skill* checkSkill = skillList->get(i);
if (checkSkill->isRequiredSkillOf(skill))
return false;
}
if(creature->hasSkill("force_title_jedi_rank_03") && skillName.contains("force_discipline_") && !knightPrereqsMet(creature, skillName)) {
return false;
}
//If they have already surrendered the skill, then return true.
if (!creature->hasSkill(skill->getSkillName()))
return true;
creature->removeSkill(skill, notifyClient);
//Remove skill modifiers
VectorMap<String, int>* skillModifiers = skill->getSkillModifiers();
ManagedReference<PlayerObject*> ghost = creature->getPlayerObject();
for (int i = 0; i < skillModifiers->size(); ++i) {
VectorMapEntry<String, int>* entry = &skillModifiers->elementAt(i);
creature->removeSkillMod(SkillModManager::SKILLBOX, entry->getKey(), entry->getValue(), notifyClient);
}
if (ghost != NULL) {
//Give the player the used skill points back.
ghost->addSkillPoints(skill->getSkillPointsRequired());
//Remove abilities but only if the creature doesn't still have a skill that grants the
//ability. Some abilities are granted by multiple skills. For example Dazzle for dancers
//and musicians.
Vector<String>* skillAbilities = skill->getAbilities();
if (skillAbilities->size() > 0) {
SortedVector<String> abilitiesLost;
for (int i = 0; i < skillAbilities->size(); i++) {
abilitiesLost.put(skillAbilities->get(i));
}
for (int i = 0; i < skillList->size(); i++) {
Skill* remainingSkill = skillList->get(i);
Vector<String>* remainingAbilities = remainingSkill->getAbilities();
for(int j = 0; j < remainingAbilities->size(); j++) {
if (abilitiesLost.contains(remainingAbilities->get(j))) {
abilitiesLost.drop(remainingAbilities->get(j));
if (abilitiesLost.size() == 0) {
break;
}
}
}
}
if (abilitiesLost.size() > 0) {
removeAbilities(ghost, abilitiesLost, notifyClient);
}
}
//Remove draft schematic groups
Vector<String>* schematicsGranted = skill->getSchematicsGranted();
SchematicMap::instance()->removeSchematics(ghost, *schematicsGranted, notifyClient);
//Update maximum experience.
updateXpLimits(ghost);
/// Update Force Power Max
ghost->setForcePowerMax(creature->getSkillMod("jedi_force_power_max"), true);
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;
}
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;
}
