/*
Noeppel, Noeppel...NOOOOOOOH
*/
package net.sf.l2j.gameserver.datatables;
import java.io.File;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javolution.util.FastList;
import javolution.util.FastMap;
import net.sf.l2j.L2DatabaseFactory;
import net.sf.l2j.gameserver.model.L2EnchantSkillLearn;
import net.sf.l2j.gameserver.model.L2PledgeSkillLearn;
import net.sf.l2j.gameserver.model.L2Skill;
import net.sf.l2j.gameserver.model.L2SkillLearn;
import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
import net.sf.l2j.gameserver.model.base.ClassId;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
/**
* This class ...
*
* @version $Revision: 1.13.2.2.2.8 $ $Date: 2005/04/06 16:13:25 $
*/
public class SkillTreeTable
{
private static Logger _log = Logger.getLogger(SkillTreeTable.class.getName());
private static SkillTreeTable _instance;
private Map<ClassId, Map<Integer,L2SkillLearn>> _skillTrees;
private List<L2SkillLearn> _fishingSkillTrees; //all common skills (teached by Fisherman)
private List<L2SkillLearn> _expandDwarfCraftSkillTrees; //list of special skill for dwarf (expand dwarf craft) learned by class teacher
private List<L2PledgeSkillLearn> _pledgeSkillTrees; //pledge skill list
private List<L2EnchantSkillLearn> _enchantSkillTrees; //enchant skill list
private Map<Integer,Map<Integer,L2SkillLearn>> _skillsById;
private Map<Integer,Integer> _nohSkillLevel;
private Map<Integer,List<Integer>> _nohSkills;
private Map<Integer,Integer> _indexToId;
private Map<Integer,Integer> _idToIndex;
private int _iD=140;
private int getId(){
_iD++;
return _iD;
}
public int parseNohSkill(Node n){
if ("skill".equalsIgnoreCase(n.getNodeName())){
NamedNodeMap attrs = n.getAttributes();
int id = Integer.parseInt(attrs.getNamedItem("id").getNodeValue());
int lvl= Integer.parseInt(attrs.getNamedItem("level").getNodeValue());
int mih=0;
//<Skill id="141" level="1" name="weapon mastery I" groupId="1" nodeName="1">
if(attrs.getNamedItem("xId")!=null)mih=Integer.parseInt(attrs.getNamedItem("xId").getNodeValue());
int xId;
if(mih!=0)xId=mih;
else xId=getId();
_indexToId.put(xId,id);
_idToIndex.put(id,xId);
_nohSkillLevel.put(xId,lvl);
//if(id==1177)_log.warning("1177:"+xId);
//if(id==142)_log.warning("142:"+xId);
_log.warning("skill id: "+id+" lvl: "+lvl+" xId: "+xId);
List<Integer> noh=new FastList<Integer>();
//_log.warning("Skill id="+xId+" id="+id);
for (Node d=n.getFirstChild(); d != null; d = d.getNextSibling()){
int i=parseNohSkill(d);
_log.warning("child id="+i);
if(i!=0)noh.add(i);
}
_nohSkills.put(xId,noh);
return xId;
}
return 0;
}
public static SkillTreeTable getInstance()
{
if (_instance == null)
_instance = new SkillTreeTable();
return _instance;
}
/**
* Return the minimum level needed to have this Expertise.<BR><BR>
*
* @param grade The grade level searched
*/
public int indexToId(int x){
return _indexToId.get(x);
}
public int idToIndex(int x){
return _idToIndex.get(x);
}
public int getExpertiseLevel(int grade)
{
if (grade <= 0)
return 0;
// since expertise comes at same level for all classes we use paladin for now
Map<Integer,L2SkillLearn> learnMap = getSkillTrees().get(ClassId.paladin);
int skillHashCode = SkillTable.getSkillHashCode(239,grade);
if (learnMap.containsKey(skillHashCode))
{
return learnMap.get(skillHashCode).getMinLevel();
}
_log.severe("Expertise not found for grade "+grade);
return 0;
}
/**
* Each class receives new skill on certain levels, this methods allow the retrieval of the minimun character level
* of given class required to learn a given skill
* @param skillId The iD of the skill
* @param classID The classId of the character
* @param skillLvl The SkillLvl
* @return The min level
*/
public int getMinSkillLevel(int skillId, ClassId classId, int skillLvl)
{
Map<Integer,L2SkillLearn> map = getSkillTrees().get(classId);
int skillHashCode = SkillTable.getSkillHashCode(skillId,skillLvl);
if (map.containsKey(skillHashCode))
{
return map.get(skillHashCode).getMinLevel();
}
return 0;
}
public int getMinSkillLevel(int skillId, int skillLvl)
{
int skillHashCode = SkillTable.getSkillHashCode(skillId, skillLvl);
// Look on all classes for this skill (takes the first one found)
for (Map<Integer,L2SkillLearn> map : getSkillTrees().values())
{
// checks if the current class has this skill
if (map.containsKey(skillHashCode))
{
return map.get(skillHashCode).getMinLevel();
}
}
return 0;
}
private SkillTreeTable()
{
int classId = 0;
int count = 0;
_idToIndex=new FastMap<Integer,Integer>();
_indexToId=new FastMap<Integer,Integer>();
_nohSkills=new FastMap<Integer,List<Integer>>();
_nohSkillLevel=new FastMap<Integer,Integer>();
try
{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
factory.setIgnoringComments(true);
File file = new File("data/noh/Skills.xml");
_log.warning("start parse");
if (!file.exists())
{
_log.warning("NO FILE");
}
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse( file );
Node rootNode = document.getDocumentElement();
Document doc = factory.newDocumentBuilder().parse(file);
Node n=doc.getFirstChild();
parseNohSkill(n);
}
catch (Exception e)
{System.out.println(e);
}
java.sql.Connection con = null;
_skillsById=new FastMap<Integer, Map<Integer,L2SkillLearn>>();
try
{
con = L2DatabaseFactory.getInstance().getConnection();
PreparedStatement statement = con.prepareStatement("SELECT * FROM class_list ORDER BY id");
ResultSet classlist = statement.executeQuery();
Map<Integer, L2SkillLearn> map;
int parentClassId;
L2SkillLearn skillLearn;
while (classlist.next())
{
map = new FastMap<Integer, L2SkillLearn>();
parentClassId = classlist.getInt("parent_id");
classId = classlist.getInt("id");
PreparedStatement statement2 = con.prepareStatement("SELECT class_id, skill_id, level, name, sp, min_level FROM skill_trees where class_id=? ORDER BY skill_id, level");
statement2.setInt(1, classId);
ResultSet skilltree = statement2.executeQuery();
if (parentClassId != -1)
{
Map<Integer, L2SkillLearn> parentMap = getSkillTrees().get(ClassId.values()[parentClassId]);
map.putAll(parentMap);
}
int prevSkillId = -1;
while (skilltree.next())
{
int id = skilltree.getInt("skill_id");
int lvl = skilltree.getInt("level");
String name = skilltree.getString("name");
int minLvl = skilltree.getInt("min_level");
int cost = skilltree.getInt("sp");
if (prevSkillId != id)
prevSkillId = id;
skillLearn = new L2SkillLearn(id, lvl, minLvl, name, cost, 0, 0);
map.put(SkillTable.getSkillHashCode(id,lvl), skillLearn);
if(_skillsById.get(id)==null){
_skillsById.put(id,new FastMap<Integer,L2SkillLearn>());
}
Map<Integer,L2SkillLearn> temp=_skillsById.get(id);
temp.put(SkillTable.getSkillHashCode(id,lvl), skillLearn);
_skillsById.put(id,temp);
}
getSkillTrees().put(ClassId.values()[classId], map);
skilltree.close();
statement2.close();
count += map.size();
_log.fine("SkillTreeTable: skill tree for class " + classId + " has " + map.size() + " skills");
}
classlist.close();
statement.close();
}
catch (Exception e)
{
_log.severe("Error while creating skill tree (Class ID " + classId + "):" + e);
}
_log.config("SkillTreeTable: Loaded " + count + " skills.");
//Skill tree for fishing skill (from Fisherman)
int count2 = 0;
int count3 = 0;
try
{
_fishingSkillTrees = new FastList<L2SkillLearn>();
_expandDwarfCraftSkillTrees = new FastList<L2SkillLearn>();
PreparedStatement statement = con.prepareStatement("SELECT skill_id, level, name, sp, min_level, costid, cost, isfordwarf FROM fishing_skill_trees ORDER BY skill_id, level");
ResultSet skilltree2 = statement.executeQuery();
int prevSkillId = -1;
while (skilltree2.next())
{
int id = skilltree2.getInt("skill_id");
int lvl = skilltree2.getInt("level");
String name = skilltree2.getString("name");
int minLvl = skilltree2.getInt("min_level");
int cost = skilltree2.getInt("sp");
int costId = skilltree2.getInt("costid");
int costCount = skilltree2.getInt("cost");
int isDwarven = skilltree2.getInt("isfordwarf");
if (prevSkillId != id)
prevSkillId = id;
L2SkillLearn skill = new L2SkillLearn(id, lvl, minLvl, name, cost, costId, costCount);
if (isDwarven == 0)
_fishingSkillTrees.add(skill);
else
_expandDwarfCraftSkillTrees.add(skill);
}
skilltree2.close();
statement.close();
count2 = _fishingSkillTrees.size();
count3 = _expandDwarfCraftSkillTrees.size();
}
catch (Exception e)
{
_log.severe("Error while creating fishing skill table: " + e);
}
int count4 = 0;
try
{
_enchantSkillTrees = new FastList<L2EnchantSkillLearn>();
PreparedStatement statement = con.prepareStatement("SELECT skill_id, level, name, base_lvl, sp, min_skill_lvl, exp, success_rate76, success_rate77, success_rate78 FROM enchant_skill_trees ORDER BY skill_id, level");
ResultSet skilltree3 = statement.executeQuery();
int prevSkillId = -1;
while (skilltree3.next())
{
int id = skilltree3.getInt("skill_id");
int lvl = skilltree3.getInt("level");
String name = skilltree3.getString("name");
int baseLvl = skilltree3.getInt("base_lvl");
int minSkillLvl = skilltree3.getInt("min_skill_lvl");
int sp = skilltree3.getInt("sp");
int exp = skilltree3.getInt("exp");
byte rate76 = skilltree3.getByte("success_rate76");
byte rate77 = skilltree3.getByte("success_rate77");
byte rate78 = skilltree3.getByte("success_rate78");
if (prevSkillId != id)
prevSkillId = id;
L2EnchantSkillLearn skill = new L2EnchantSkillLearn(id, lvl, minSkillLvl, baseLvl, name, sp, exp, rate76 , rate77, rate78);
_enchantSkillTrees.add(skill);
}
skilltree3.close();
statement.close();
count4 = _enchantSkillTrees.size();
}
catch (Exception e)
{
_log.severe("Error while creating enchant skill table: " + e);
}
int count5 = 0;
try
{
_pledgeSkillTrees = new FastList<L2PledgeSkillLearn>();
PreparedStatement statement = con.prepareStatement("SELECT skill_id, level, name, clan_lvl, repCost, itemId FROM pledge_skill_trees ORDER BY skill_id, level");
ResultSet skilltree4 = statement.executeQuery();
int prevSkillId = -1;
while (skilltree4.next())
{
int id = skilltree4.getInt("skill_id");
int lvl = skilltree4.getInt("level");
String name = skilltree4.getString("name");
int baseLvl = skilltree4.getInt("clan_lvl");
int sp = skilltree4.getInt("repCost");
int itemId = skilltree4.getInt("itemId");
if (prevSkillId != id)
prevSkillId = id;
L2PledgeSkillLearn skill = new L2PledgeSkillLearn(id, lvl, baseLvl, name, sp, itemId);
_pledgeSkillTrees.add(skill);
}
skilltree4.close();
statement.close();
count5 = _pledgeSkillTrees.size();
}
catch (Exception e)
{
_log.severe("Error while creating fishing skill table: " + e);
}
finally
{
try { con.close(); } catch (Exception e) {}
}
_log.config("FishingSkillTreeTable: Loaded " + count2 + " general skills.");
_log.config("FishingSkillTreeTable: Loaded " + count3 + " dwarven skills.");
_log.config("EnchantSkillTreeTable: Loaded " + count4 + " enchant skills.");
_log.config("PledgeSkillTreeTable: Loaded " + count5 + " pledge skills");
}
private Map<ClassId, Map<Integer, L2SkillLearn>> getSkillTrees()
{
if (_skillTrees == null)
_skillTrees = new FastMap<ClassId, Map<Integer, L2SkillLearn>>();
return _skillTrees;
}
public L2SkillLearn[] getAvailableSkills(L2PcInstance cha, ClassId classId2)
{
List<L2SkillLearn> result = new FastList<L2SkillLearn>();
Map<Integer,Boolean> test= new FastMap<Integer,Boolean>();
Collection<L2SkillLearn> skills = new FastList<L2SkillLearn>();
for(int i : cha.getNohSkill().getSkills()){
Map<Integer,L2SkillLearn> temp=_skillsById.get(i);
for(L2SkillLearn x : temp.values()){
skills.add(x);
}
}
/*for(Map<Integer,L2SkillLearn> temp : _skillsById.values()){
skills.addAll(temp.values());
}*/
if(skills!=null){
L2Skill[] oldSkills = cha.getAllSkills();
for (L2SkillLearn temp : skills)
{
if (temp.getMinLevel() <= cha.getLevel())
{
boolean knownSkill = false;
for (int j = 0; j < oldSkills.length && !knownSkill; j++)
{
if (oldSkills[j].getId() == temp.getId() )
{
knownSkill = true;
if ( oldSkills[j].getLevel() == temp.getLevel()-1)
{
// this is the next level of a skill that we know
for(int x : cha.getNohSkill().getSkills()){
if(temp.getId()==x){
if(test.get(x)==null){
result.add(temp);
test.put(x,true);
}
}
}
}
}
}
if (!knownSkill && temp.getLevel() == 1)
{
// this is a new skill
for(int x : cha.getNohSkill().getSkills()){
if(temp.getId()==x){
if(test.get(x)==null){
result.add(temp);
test.put(x,true);
}
}
}
}
}
}}
if (result == null)
{
// the skilltree for this class is undefined, so we give an empty list
_log.warning("Skilltree for class is not defined !");
return new L2SkillLearn[0];
}
return result.toArray(new L2SkillLearn[result.size()]);
}
public L2SkillLearn[] getAvailableSkills(L2PcInstance cha)
{
List<L2SkillLearn> result = new FastList<L2SkillLearn>();
List<L2SkillLearn> skills = new FastList<L2SkillLearn>();
skills.addAll(_fishingSkillTrees);
if (skills == null)
{
// the skilltree for this class is undefined, so we give an empty list
_log.warning("Skilltree for fishing is not defined !");
return new L2SkillLearn[0];
}
if (cha.hasDwarvenCraft() && _expandDwarfCraftSkillTrees != null)
{
skills.addAll(_expandDwarfCraftSkillTrees);
}
L2Skill[] oldSkills = cha.getAllSkills();
for (L2SkillLearn temp : skills)
{
if (temp.getMinLevel() <= cha.getLevel())
{
boolean knownSkill = false;
for (int j = 0; j < oldSkills.length && !knownSkill; j++)
{
if (oldSkills[j].getId() == temp.getId() )
{
knownSkill = true;
if ( oldSkills[j].getLevel() == temp.getLevel()-1)
{
// this is the next level of a skill that we know
result.add(temp);
}
}
}
if (!knownSkill && temp.getLevel() == 1)
{
// this is a new skill
result.add(temp);
}
}
}
return result.toArray(new L2SkillLearn[result.size()]);
}
public L2EnchantSkillLearn[] getAvailableEnchantSkills(L2PcInstance cha)
{
List<L2EnchantSkillLearn> result = new FastList<L2EnchantSkillLearn>();
List<L2EnchantSkillLearn> skills = new FastList<L2EnchantSkillLearn>();
skills.addAll(_enchantSkillTrees);
if (skills == null)
{
// the skilltree for this class is undefined, so we give an empty list
_log.warning("Skilltree for enchanting is not defined !");
return new L2EnchantSkillLearn[0];
}
L2Skill[] oldSkills = cha.getAllSkills();
for (L2EnchantSkillLearn temp : skills)
{
if (76 <= cha.getLevel())
{
boolean knownSkill = false;
for (int j = 0; j < oldSkills.length && !knownSkill; j++)
{
if (oldSkills[j].getId() == temp.getId() )
{
knownSkill = true;
if ( oldSkills[j].getLevel() == temp.getMinSkillLevel())
{
// this is the next level of a skill that we know
result.add(temp);
}
}
}
}
}
//cha.sendMessage("loaded "+ result.size()+" enchant skills for this char(You)");
return result.toArray(new L2EnchantSkillLearn[result.size()]);
}
public L2PledgeSkillLearn[] getAvailablePledgeSkills(L2PcInstance cha)
{
List<L2PledgeSkillLearn> result = new FastList<L2PledgeSkillLearn>();
List<L2PledgeSkillLearn> skills = _pledgeSkillTrees;
if (skills == null)
{
// the skilltree for this class is undefined, so we give an empty list
_log.warning("No clan skills defined!");
return new L2PledgeSkillLearn[0];
}
L2Skill[] oldSkills = cha.getClan().getAllSkills();
for (L2PledgeSkillLearn temp : skills)
{
if (temp.getBaseLevel() <= cha.getClan().getLevel())
{
boolean knownSkill = false;
for (int j = 0; j < oldSkills.length && !knownSkill; j++)
{
if (oldSkills[j].getId() == temp.getId() )
{
knownSkill = true;
if ( oldSkills[j].getLevel() == temp.getLevel()-1)
{
// this is the next level of a skill that we know
result.add(temp);
}
}
}
if (!knownSkill && temp.getLevel() == 1)
{
// this is a new skill
result.add(temp);
}
}
}
return result.toArray(new L2PledgeSkillLearn[result.size()]);
}
/**
* Returns all allowed skills for a given class.
* @param classId
* @return all allowed skills for a given class.
*/
public Collection<L2SkillLearn> getAllowedSkills(ClassId classId)
{
return getSkillTrees().get(classId).values();
}
public int getMinLevelForNewSkill(L2PcInstance cha, ClassId classId)
{
int minLevel = 0;
Collection<L2SkillLearn> skills = getSkillTrees().get(classId).values();
if (skills == null)
{
// the skilltree for this class is undefined, so we give an empty list
_log.warning("Skilltree for class " + classId + " is not defined !");
return minLevel;
}
for (L2SkillLearn temp: skills)
{
if (temp.getMinLevel() > cha.getLevel() && temp.getSpCost() != 0)
if (minLevel==0 || temp.getMinLevel()<minLevel)
minLevel = temp.getMinLevel();
}
return minLevel;
}
public int getMinLevelForNewSkill(L2PcInstance cha)
{
int minLevel = 0;
List<L2SkillLearn> skills = new FastList<L2SkillLearn>();
skills.addAll(_fishingSkillTrees);
if (skills == null)
{
// the skilltree for this class is undefined, so we give an empty list
_log.warning("SkillTree for fishing is not defined !");
return minLevel;
}
if (cha.hasDwarvenCraft() && _expandDwarfCraftSkillTrees != null)
{
skills.addAll(_expandDwarfCraftSkillTrees);
}
for (L2SkillLearn s : skills)
{
if (s.getMinLevel() > cha.getLevel())
if (minLevel == 0 || s.getMinLevel() < minLevel)
minLevel = s.getMinLevel();
}
return minLevel;
}
public int getSkillCost(L2PcInstance player, L2Skill skill)
{
int skillCost = 100000000;
int skillHashCode = SkillTable.getSkillHashCode(skill);
int skillId=skill.getId();
if (_skillsById.get(skillId).containsKey(skillHashCode))
{
L2SkillLearn skillLearn = _skillsById.get(skillId).get(skillHashCode);
if (skillLearn.getMinLevel() <= player.getLevel())
{
return skillLearn.getSpCost();
}
}
return skillCost;
}
public List<Integer> getNohSkills(int index, int level){
List<Integer> nohs =_nohSkills.get(index);
List<Integer> result=new FastList<Integer>();
if(nohs==null){
_log.warning("Scheisse-.-");
return null;
}
if(nohs.isEmpty()){
_log.warning("Scheisse-.-");
return null;
}
for(int x : nohs){
if(level>=_nohSkillLevel.get(x))result.add(x);
}
return result;
}
public String getSkillName(int id){
Map<Integer,L2SkillLearn> ski=_skillsById.get(id);
String name="leer";
for( L2SkillLearn skil : ski.values()){
name=skil.getName();
}
return name;
}
public int getSkillSpCost(L2PcInstance player, L2Skill skill)
{
int skillCost = 100000000;
L2EnchantSkillLearn[] enchantSkillLearnList = getAvailableEnchantSkills(player);
for (L2EnchantSkillLearn enchantSkillLearn : enchantSkillLearnList)
{
if (enchantSkillLearn.getId() != skill.getId())
continue;
if (enchantSkillLearn.getLevel() != skill.getLevel())
continue;
if (76 > player.getLevel())
continue;
skillCost = enchantSkillLearn.getSpCost();
}
return skillCost;
}
public int getSkillExpCost(L2PcInstance player, L2Skill skill)
{
int skillCost = 100000000;
L2EnchantSkillLearn[] enchantSkillLearnList = getAvailableEnchantSkills(player);
for (L2EnchantSkillLearn enchantSkillLearn : enchantSkillLearnList)
{
if (enchantSkillLearn.getId() != skill.getId())
continue;
if (enchantSkillLearn.getLevel() != skill.getLevel())
continue;
if (76 > player.getLevel())
continue;
skillCost = enchantSkillLearn.getExp();
}
return skillCost;
}
public byte getSkillRate(L2PcInstance player, L2Skill skill)
{
L2EnchantSkillLearn[] enchantSkillLearnList = getAvailableEnchantSkills(player);
for (L2EnchantSkillLearn enchantSkillLearn : enchantSkillLearnList)
{
if (enchantSkillLearn.getId() != skill.getId())
continue;
if (enchantSkillLearn.getLevel() != skill.getLevel())
continue;
return enchantSkillLearn.getRate(player);
}
return 0;
}
}