public string DECOVALUERAW(string attributename)
{
return(AttributesData
.FirstOrDefault(a =>
string.Compare(a.NAME, attributename, StringComparison.OrdinalIgnoreCase) == 0)?.Parameters
?.FirstOrDefault() ?? "");
}
/// <summary>
/// Busca os valores do atributo
/// </summary>
/// <param name="dataDb"></param>
/// <param name="attribure"></param>
/// <param name="label"></param>
/// <param name="high"></param>
/// <param name="low"></param>
/// <param name="moderate"></param>
private void GetAttributeValues(DataTable dataDb, AttributesData attribure, string label, out int high, out int low, out int moderate)
{
high = 0;
low = 0;
moderate = 0;
foreach (DataRow row in dataDb.Rows)
{
if ((string)row[attribure.Name] == label)
{
if ((string)row[AttributeLabel] == "alto")
{
high++;
}
else if ((string)row[AttributeLabel] == "baixo")
{
low++;
}
else if ((string)row[AttributeLabel] == "moderado")
{
moderate++;
}
}
}
}
public static AttributesData operator -(AttributesData att1, AttributesData att2)
{
AttributesData attributes = new AttributesData();
attributes.Health = att1.Health - att2.Health;
attributes.Str = att1.Str - att2.Str;
attributes.Mag = att1.Mag - att2.Mag;
attributes.Dex = att1.Dex - att2.Dex;
attributes.Agi = att1.Agi - att2.Agi;
attributes.Will = att1.Will - att2.Will;
return attributes;
}
public static AttributesData operator +(AttributesData att1, AttributesData att2)
{
AttributesData attributes = new AttributesData();
attributes.Health = att1.Health + att2.Health;
attributes.Str = att1.Str + att2.Str;
attributes.Mag = att1.Mag + att2.Mag;
attributes.Dex = att1.Dex + att2.Dex;
attributes.Agi = att1.Agi + att2.Agi;
attributes.Will = att1.Will + att2.Will;
return attributes;
}
public override void ParseXML(XMLNode x)
{
base.ParseXML(x);
Attributes = x.Select <AttributesData>("attributes");
Stats = x.Select <Stats>("stats");
Flags = new GenericFlags <NPCFlags>(x.SelectEnums <NPCFlags>("flags"));
SpawnKeywords = new GenericFlags <SpawnKeywords>(x.SelectEnums <SpawnKeywords>("spawnkeywords"));
KnownSpells = x.Select <Spells>("spells");
StartingItems = x.Select <StartingItems>("startingitems");
Equipment = x.Select <Equipment>("equipslots");
NaturalWeapon = x.Select <Item>("naturalweapon");
//parse AI packages
}
public static Dictionary<AttributeType, int> Convert(AttributesData data)
{
Dictionary<AttributeType, int> attributes = new Dictionary<AttributeType, int>();
attributes.Add(AttributeType.Health, data.Health);
attributes.Add(AttributeType.Strength, data.Str);
attributes.Add(AttributeType.Magic, data.Mag);
attributes.Add(AttributeType.Agility, data.Agi);
attributes.Add(AttributeType.Dexterity, data.Dex);
attributes.Add(AttributeType.WillPower, data.Will);
attributes.Add(AttributeType.Armor, 0);
attributes.Add(AttributeType.MagicArmor, 0);
return attributes;
}
private static void LoadBasicStats(Player player)
{
AttributesData attr = new AttributesData();
attr.Constitution = 14;
attr.Charisma = 12;
attr.Wisdom = 9;
attr.Dexterity = 17;
attr.Intelligence = 16;
attr.Strength = 16;
attr.Size = Size.MEDIUM;
player.Attributes = attr;
Stats stats = new Stats();
//stats.MaxHealth = 100;
stats.MaxPower = 50;
stats.Level = 1;
stats.initialize();
stats.Hunger = 900;
player.Stats = stats;
GenericFlags <NPCFlags> flags = new GenericFlags <NPCFlags>();
flags[NPCFlags.NOPOLY] = true;
flags[NPCFlags.NO_RANDOM_SPAWN] = true;
player.Flags = flags;
player.PlayerTitle = BigBoss.Objects.PlayerProfessions.getTitle(player.PlayerChosenProfession, player.Stats.Level);
player.IsActive = true;
Equipment equipment = new Equipment();
player.Equipment = equipment;
equipment.AddSlot(EquipType.BODY);
equipment.AddSlot(EquipType.FEET);
equipment.AddSlot(EquipType.HAND, 2);
equipment.AddSlot(EquipType.HEAD);
equipment.AddSlot(EquipType.LEGS);
equipment.AddSlot(EquipType.NECK);
equipment.AddSlot(EquipType.RING, 2);
equipment.AddSlot(EquipType.SHIRT);
player.Name = "Kurtis";
foreach (KeyValuePair <string, Spell> kvp in BigBoss.Objects.PlayerSpells)
{
player.KnownSpells.Add(kvp.Key, kvp.Value);
}
}
/// <summary>
/// Calcula o ganho
/// </summary>
/// <param name="dataDb"></param>
/// <param name="attribure"></param>
/// <returns></returns>
private double GainCalc(DataTable dataDb, AttributesData attribure)
{
ArrayList values = attribure.PropetiesValues;
double soma = 0.0;
for (int item = 0; item < values.Count; item++)
{
int high, low, moderate = 0;
GetAttributeValues(dataDb, attribure, values[item].ToString(), out high, out low, out moderate);
double entropia = EntropyCalc(high, low, moderate);
soma += -(double)(high + low + moderate) / Total * entropia;
}
return(this.Entropy + soma);
}
/// Retorna o melhor attribure
private AttributesData GetAttributeBest(DataTable dataDb, AttributesData[] attributesDb)
{
double maximoGanho = 0.0;
AttributesData result = null;
foreach (AttributesData attribure in attributesDb)
{
double aux = GainCalc(dataDb, attribure);
if (aux > maximoGanho)
{
maximoGanho = aux;
result = attribure;
}
}
return(result);
}
public static AttributesData[] InitAttributes()
{
AttributesData risco = new AttributesData("risco", new ArrayList {
"alto", "moderado", "baixo"
});
AttributesData historico_credito = new AttributesData("historico_credito", new ArrayList {
"ruim", "desconhecida", "boa"
});
AttributesData divida = new AttributesData("divida", new ArrayList {
"alta", "baixa"
});
AttributesData garantia = new AttributesData("garantia", new ArrayList {
"nenhuma", "adequada"
});
AttributesData renda = new AttributesData("renda", new ArrayList {
"$0 a $15 mil", "$15 a $35 mil", "acima de $35 mil"
});
return(new AttributesData[] { historico_credito, divida, garantia, renda });
}
/// <summary>
/// Constrói a árvore realizando a indução.
/// </summary>
/// <param name="dataDb"></param>
/// <param name="label"></param>
/// <param name="attributesDb"></param>
/// <returns></returns>
private Node BuildInternalTee(DataTable dataDb, string label, AttributesData[] attributesDb)
{
if (ChecksAllBelongsClassSame(dataDb, label).Count == 1)
{
return(new Node(new AttributesData(dataDb.Rows[0])));
}
if (attributesDb.Length == 0)
{
return(new Node(new AttributesData(GetMostCommonValue(dataDb, label))));
}
this.Total = dataDb.Rows.Count;
this.AttributeLabel = label;
this.TotalHigh = RiscTotal(dataDb, "alto");
this.TotalLow = RiscTotal(dataDb, "baixo");
this.TotalModerate = RiscTotal(dataDb, "moderado");
this.Entropy = EntropyCalc(this.TotalHigh, this.TotalLow, this.TotalModerate);
AttributesData melhorAtributo = GetAttributeBest(dataDb, attributesDb);
Node root = new Node(melhorAtributo);
DataTable data = dataDb.Clone();
/// Predição
foreach (var item in melhorAtributo.PropetiesValues)
{
/// Limpa a linha
data.Rows.Clear();
/// Seleciona todos os elementos com o valor deste atributo
DataRow[] rows = dataDb.Select(melhorAtributo.Name + " = " + "'" + item.ToString() + "'");
foreach (DataRow row in rows)
{
data.Rows.Add(row.ItemArray);
}
/// Cria uma nova lista/partição de attributesDb menos o atributo corrente que é o melhor atributo
ArrayList atrbts = new ArrayList(attributesDb.Length - 1);
for (int _item = 0; _item < attributesDb.Length; _item++)
{
if (attributesDb[_item].Name != melhorAtributo.Name)
{
atrbts.Add(attributesDb[_item]);
}
}
if (data.Rows.Count == 0)
{
return(new Node(new AttributesData(GetMostCommonValue(data, label))));
}
else
{
DecisionTree id3 = new DecisionTree();
Node noFilho = id3.TreeBuild(data, label, (AttributesData[])atrbts.ToArray(typeof(AttributesData)));
root.NodeCreate(noFilho, item.ToString());
}
}
return(root);
}
public IEnumerable <string> ATTRIBUTESIN(params string[] atts) => AttributesData.Select(a => a.NAME).Where(a => atts.Contains(a));
public bool DECO(params string[] attributename)
{
return(AttributesData.Any(a => attributename.Contains(a.NAME, StringComparer.OrdinalIgnoreCase)));
}
public bool DECO(string attributename)
{
return(AttributesData.Any(a =>
string.Compare(a.NAME, attributename, StringComparison.OrdinalIgnoreCase) == 0));
}
