static XmlNode CheckForExistingSpell(CharConverter app, XmlNode oldNode, String name, int levelindex)
{
XmlNodeList nodelist = oldNode.SelectSingleNode("spellset").ChildNodes;
foreach (XmlNode spellset in nodelist)
{
if (spellset.SelectSingleNode("levels") == null)
{
continue;
}
XmlNode level = spellset.SelectSingleNode("levels/level" + Convert.ToString(levelindex));
if (level == null)
{
continue;
}
XmlNodeList spells = level.SelectSingleNode("spells").ChildNodes;
foreach (XmlNode spell in spells)
{
String value = app.ValueOf(spell, "name");
if (value.Equals(name))
{
return(spell);
}
}
}
return(null);
}
static public void processAttackbonusGrappleSize(CharConverter app, String call, ref XmlNode inChar, ref XmlNode outChar, ref XmlNode targetNode)
{
int size = CharConverter.ConvertToInt(targetNode.InnerText);
size *= -1;
targetNode.InnerText = Convert.ToString(size);
}
static public XmlNode CheckForExistingPower(CharConverter app, XmlNode node, String name)
{
String value;
XmlNode nodePowers = node.SelectSingleNode("powers");
XmlNodeList powers = nodePowers.ChildNodes;
for (int nPower = powers.Count - 1; nPower >= 0; nPower--)
{
XmlNode nodePower = powers[nPower];
value = app.ValueOf(nodePower, "name");
if (name.Equals(value))
{
return(nodePower);
}
}
/* DEBUG
* XmlNodeList nodelist = node.SelectNodes("powers/*");
* for (int powercatindex = 0; powercatindex < nodelist.Count; powercatindex++)
* {
* XmlNode powercat = nodelist[powercatindex];
* XmlNode powernode = powercat.SelectSingleNode("power");
* XmlNodeList powers = powernode.ChildNodes;
* for (int powerindex = powers.Count - 1; powerindex >= 0; powerindex--)
* {
* XmlNode power = powers[powerindex];
* value = app.ValueOf(power, "name");
* if (name.Equals(value))
* return power;
* }
* }
*/
return(null);
}
static public void processProficiencyarmor(CharConverter app, String call, ref XmlNode inChar, ref XmlNode outChar, ref XmlNode targetNode)
{
var ApiAtributes = app.ParseApiAttributes(call);
String featlist = ApiAtributes.ContainsKey("featlist") ? ApiAtributes["featlist"] : "featlist";
XmlNode node = outChar.SelectSingleNode(featlist);
XmlNodeList nodelist = node.ChildNodes;
XmlNode armorpro = targetNode;
for (int i = nodelist.Count - 1; i >= 0; i--)
{
XmlNode feat = nodelist[i];
String value = app.ValueOf(feat, "value");
XmlNode target = null;
if (value.Contains("Armor Proficiency"))
{
value = value.Split(',')[1].Substring(1);
target = armorpro;
}
else if (value.Contains("Shield Proficiency"))
{
String[] valuesplit = value.Split(' ');
var shsb = new StringBuilder();
foreach (String shvalue in valuesplit)
{
if (shvalue.Equals("Proficiency"))
{
break;
}
shsb.Append(shvalue);
shsb.Append(" ");
}
shsb.Remove(shsb.Length - 1, 1);
value = shsb.ToString();
target = armorpro;
node.RemoveChild(node.ChildNodes[i]);
}
if (target != null)
{
if (app.CheckForDuplicateValue(armorpro, value))
{
continue;
}
target.AppendChild(outChar.OwnerDocument.CreateElement(CharConverter.CreateId(target)));
target.LastChild.AppendChild(CharConverter.CreateElement(outChar.OwnerDocument, "value", "string", value));
value = app.ValueOf(feat, "description");
target.LastChild.AppendChild(CharConverter.CreateElement(outChar.OwnerDocument, "description", "string", value));
}
}
}
static public void processSpeedSpecial(CharConverter app, String call, ref XmlNode inChar, ref XmlNode outChar, ref XmlNode targetNode)
{
//speed/special
String value = targetNode.InnerText;
var strbu = new StringBuilder();
String[] speedspecial = value.Split(':');
for (int i = 1; i < speedspecial.Length; i += 2)
{
strbu.Append(speedspecial[i]);
strbu.Append(i + 2 >= speedspecial.Length ? "." : ", ");
}
targetNode.InnerText = strbu.ToString();
}
static public void processSpellset(CharConverter app, String call, ref XmlNode inChar, ref XmlNode outChar, ref XmlNode targetNode)
{
foreach (XmlNode spellset in targetNode.ChildNodes)
{
if (spellset.SelectSingleNode("levels") == null)
{
continue;
}
foreach (XmlNode level in spellset.SelectSingleNode("levels").ChildNodes)
{
foreach (XmlNode spell in level.SelectSingleNode("spells").ChildNodes)
{
String value = app.ValueOf(spell, "school");
String[] school = value.Split(':');
var sb = new StringBuilder();
sb.Append(school[0]);
var innerbra = new StringBuilder();
for (int i = 1; i < school.Length; i++)
{
value = school[i];
if (!String.IsNullOrEmpty(value))
{
innerbra.Append(value);
}
if (i + 1 < school.Length &&
!String.IsNullOrEmpty(school[i + 1]))
{
innerbra.Append(",");
}
}
if (!String.IsNullOrEmpty(innerbra.ToString()))
{
sb.Append(" [").Append(innerbra.ToString()).Append("]");
}
app.Set(spell, "school", sb.ToString());
}
}
}
XmlNodeList nodelist = targetNode.ChildNodes;
for (int i = nodelist.Count - 1; i >= 0; i--)
{
if (nodelist[i].ChildNodes.Count <= 1)
{
targetNode.RemoveChild(nodelist[i]);
}
}
}
static public void processCoinsSlot2(CharConverter app, String call, ref XmlNode inChar, ref XmlNode outChar, ref XmlNode targetNode)
{
//coins/slot2/amount
String value = targetNode.InnerText;
if (!String.IsNullOrEmpty(value))
{
String[] gold = value.Split(' ');
int goldamount = 0;
for (int i = 0; i < gold.Length; i++)
{
goldamount += CharConverter.ConvertToInt(gold[i].Split('.')[0]);
}
targetNode.InnerText = Convert.ToString(goldamount);
}
}
static public void ReplaceCharacter(CharConverter app, XmlNode parentNode, XmlNode newNode, XmlNode oldNode)
{
//powers
/* DEBUG
* XmlNodeList nodelist = newNode.SelectSingleNode("powers").ChildNodes;
* for (int powercatindex = 0; powercatindex < nodelist.Count; powercatindex++)
* {
* XmlNode powercat = nodelist[powercatindex];
* XmlNode powernode = powercat.SelectSingleNode("power");
* XmlNodeList powers = powernode.ChildNodes;
* foreach (XmlNode power in powers)
* {
* String value = app.ValueOf(power, "name");
* XmlNode existingpower = CheckForExistingPower(app, oldNode, value);
*
* if (existingpower == null)
* continue;
*
* powernode.RemoveChild(power);
* powernode.AppendChild(CharConverter.ImportIdNode(newNode.OwnerDocument, powernode, existingpower));
* }
* }
*/
XmlNode nodePowers = newNode.SelectSingleNode("powers");
XmlNodeList nodePowerList = nodePowers.ChildNodes;
foreach (XmlNode nodePower in nodePowerList)
{
String value = app.ValueOf(nodePower, "name");
XmlNode existingpower = CheckForExistingPower(app, oldNode, value);
if (existingpower == null)
{
continue;
}
nodePowers.RemoveChild(nodePower);
nodePowers.AppendChild(CharConverter.ImportIdNode(newNode.OwnerDocument, nodePower, existingpower));
}
//notes
app.ReplaceElement(oldNode, newNode, "notes");
//appearance
app.ReplaceElement(oldNode, newNode, "appearance");
}
static public void processSpecialabilitylist(CharConverter app, String call, ref XmlNode inChar, ref XmlNode outChar, ref XmlNode targetNode)
{
String value;
var ApiAtributes = app.ParseApiAttributes(call);
String characterClasses = "classes";
String characterName = "name";
if (ApiAtributes.ContainsKey("classes"))
{
characterClasses = ApiAtributes["classes"];
}
if (ApiAtributes.ContainsKey("name"))
{
characterName = ApiAtributes["name"];
}
foreach (XmlNode classnode in outChar.SelectSingleNode(characterClasses).ChildNodes)
{
value = app.ValueOf(classnode, "name");
//Checks for speciality
if (!value.Equals(ParseClassName(value)))
{
app.Set(classnode, characterName, ParseClassName(value));
XmlNode spabilitylist = targetNode;
XmlNode specialty = outChar.OwnerDocument.CreateElement(CharConverter.CreateId(spabilitylist));
String specialtyname = value;
value = "Specialty: " + value;
specialty.AppendChild(CharConverter.CreateElement(outChar.OwnerDocument, "value", "string", value));
value = "The specialty for the " + ParseClassName(specialtyname) + "class is " + specialtyname + ".";
specialty.AppendChild(CharConverter.CreateElement(outChar.OwnerDocument, "description", "string", value));
if (spabilitylist.ChildNodes.Count > 0)
{
spabilitylist.InsertBefore(specialty, spabilitylist.ChildNodes[0]);
}
else
{
spabilitylist.AppendChild(specialty);
}
}
}
}
static public void processSkilllist(CharConverter app, String call, ref XmlNode inChar, ref XmlNode outChar, ref XmlNode targetNode)
{
String value;
foreach (XmlNode skill in targetNode.ChildNodes)
{
String label = app.ValueOf(skill, "label");
if (label.Contains("(") &&
label.Contains(")") &&
(label.Contains("Knowledge") ||
label.Contains("Perform") ||
label.Contains("Profession") ||
label.Contains("Craft")))
{
app.Set(skill, "label", label.Split('(')[0]);
value = label.Split('(')[1].Split(')')[0];
skill.AppendChild(CharConverter.CreateElement(outChar.OwnerDocument, "sublabel", "string", value));
}
}
}
static public void ReplaceCharacter(CharConverter app, XmlNode parentNode, XmlNode newNode, XmlNode oldNode)
{
//spellset
XmlNodeList nodelist = newNode.SelectSingleNode("spellset").ChildNodes;
foreach (XmlNode spellset in nodelist)
{
if (spellset.SelectSingleNode("levels") == null)
{
continue;
}
XmlNodeList levels = spellset.SelectSingleNode("levels").ChildNodes;
for (int levelindex = 0; levelindex < levels.Count; levelindex++)
{
XmlNode level = levels[levelindex];
XmlNode spells = level.SelectSingleNode("spells");
XmlNodeList spellslist = spells.ChildNodes;
for (int i = spellslist.Count - 1; i >= 0; i--)
{
XmlNode spell = spellslist[i];
String value = app.ValueOf(spell, "name");
XmlNode existingspell = CheckForExistingSpell(app, oldNode, value, levelindex);
if (existingspell == null)
{
continue;
}
spells.RemoveChild(spell);
spells.AppendChild(CharConverter.ImportIdNode(newNode.OwnerDocument, spells, existingspell));
}
}
}
//notes
app.ReplaceElement(oldNode, newNode, "notes");
//appearance
app.ReplaceElement(oldNode, newNode, "appearance");
}
