// For Cloning
public Spell(Spell spell)
{
Name = spell.Name;
ClassType = spell.ClassType;
ClassSpec = spell.ClassSpec;
SpellIds.AddRange(spell.SpellIds);
Levels.AddRange(spell.Levels);
Talent = spell.Talent;
Icon = spell.Icon;
Cooldowns.AddRange(spell.Cooldowns);
Durations.AddRange(spell.Durations);
IsPvp = spell.IsPvp;
Range = spell.Range;
Categories = spell.Categories.ToHashSet();
Effects = spell.Effects.ToList();
Type = spell.Type;
Invert = spell.Invert;
BigStacks = spell.BigStacks;
UseIcon = spell.UseIcon;
AssociatedAuras.AddRange(spell.AssociatedAuras);
}
public static void ChangeStatsWeightSettings(ClassSpec classSpec)
{
Logger.Log($"Setting stat weight to {classSpec}");
if (!AllPresets.ContainsKey(classSpec))
{
Logger.LogError($"{classSpec} couldn't be found in the presets dictionary.");
return;
}
Dictionary <CharStat, int> preset = AllPresets[classSpec];
if (preset == null)
{
Logger.LogError($"Preset dictionary for {classSpec} doesn't exist");
return;
}
// Reset all values
AutoEquipSettings.CurrentSettings.StatWeights.Clear();
// Assign values
foreach (KeyValuePair <CharStat, int> presetToAssign in preset)
{
AutoEquipSettings.CurrentSettings.SetStat(presetToAssign.Key, presetToAssign.Value);
}
AutoEquipSettings.CurrentSettings.Save();
//AutoEquipSettings.Load();
}
private static string GenerateAuraId(ClassSpec classSpec, Spell spell)
{
var sb = new StringBuilder();
var name = spell.Name
.Replace("-", "_")
.Replace("\'", "")
.Replace(":", "")
.Replace("!", "_")
.Replace(",", "")
.Replace(")", "")
.Replace("(", "")
.Replace(" ", "_");
sb.Append(classSpec.ToAuraPrefix());
sb.Append('_');
sb.Append(name);
// sb.Append('_');
// sb.Append(spell.SpellIds.First());
//if (spell.Type.HasFlag(SpellType.Cooldown)) sb.Append("_cd");
//if (spell.Type.HasFlag(SpellType.DebuffOnTarget)) sb.Append("_debuff");
//if (spell.Type.HasFlag(SpellType.BuffOnPlayer)) sb.Append("_buff");
//if (spell.Type.HasFlag(SpellType.BuffOnTarget)) sb.Append("_tar");
// if (spell.Type.HasFlag(SpellType.DoT)) sb.Append("_dot");
// if (spell.Talent != 0) sb.Append("_t").Append(spell.Talent);
return(sb.ToString().ToLowerInvariant());
}
public EnemyOrcRanger(int expReward = 10, ClassSpec @class = ClassSpec.RANGER, string name = "OrcsmerRanger",
int healthPoint = 20, int armour = 1, int attackPower = 3)
: base(expReward, @class, name, healthPoint, armour, attackPower)
{
EquipedItems["Weapon"] = new Items.Weapons.SimpleBow();
attackBehaviour = new CharactersActions.AttackWithWeapon();
}
public EnemyOrcMage(int expReward = 10, ClassSpec @class = ClassSpec.MAGE, string name = "OrcsmerMage",
int healthPoint = 25, int armour = 0, int attackPower = 2)
: base(expReward, @class, name, healthPoint, armour, attackPower)
{
EquipedItems["Spell"] = new Items.Spells.Fireball();
attackBehaviour = new CharactersActions.AttackWithSpell();
}
// note: Use booleans are ignored and it just checks to see if the object exists or not
public static void LoadIf(this Aura aura, ClassSpec classSpec)
{
aura.Load.ClassAndSpec = new ClassAndSpec {
Single = (int)classSpec
};
aura.Load.UseClassAndSpec = true;
}
// From Code-gen
public Spell(string name, ClassType classType, ClassSpec classSpec,
int[] spellIds, int[] levels, int talent, int icon,
double[] cooldowns, double[] durations, bool isPvp, double range,
string[] categories, SpellEffectData[] data)
{
Name = name;
ClassType = classType;
ClassSpec = classSpec;
SpellIds.AddRange(spellIds);
Levels.AddRange(levels);
Talent = talent;
Icon = icon;
Cooldowns.AddRange(cooldowns);
Durations.AddRange(durations);
IsPvp = isPvp;
Range = range;
Categories = categories.ToHashSet();
Effects = data.ToList();
if (Effects.Any(e => e.AuraType == EffectAuraType.PeriodicDamage))
{
Type |= SpellType.DoT;
}
}
private Hero(ClassSpec @class, string name, int healthPoint, int armour, int attackPower)
: base(@class, name, healthPoint, armour, attackPower)
{
//attackBehaviour = new CharactersActions.AttackWithWeapon();
maxHP = healthPoint;
Expirience = 0;
Level = 0;
}
// Minimal Variant -- for humans seeking a low effort typing experience
public Spell(string name, ClassType classType, ClassSpec classSpec,
int spellId, int talent, SpellType spellType = SpellType.Cooldown)
{
Name = name;
ClassType = classType;
ClassSpec = classSpec;
SpellIds.Add(spellId);
Talent = talent;
Type = spellType;
}
public FriendlyTrader(ClassSpec @class = ClassSpec.WARRIOR, string name = "Trader", int healthPoint = 100, int armour = 0, int attackPower = 0)
: base(@class, name, healthPoint, armour, attackPower)
{
attackBehaviour = new CharactersActions.NoAttack();
quest = new Quests.AssasinationQuest();
for (int i = 0; i <= 10; i++)
{
resources.ItemList.Add(new Items.Armours.SteelArmour());
resources.ItemList.Add(new Items.Weapons.SimpleBow());
resources.ItemList.Add(new Items.Weapons.SteelSword());
}
}
public void PropertyAndClassTest()
{
ClassSpec classSpec = NapackFileAnalyzer.Analyze("Test", "unused", SampleStrings.LargeSampleClass).Classes.First();
Assert.AreEqual(1, classSpec.PublicProperties.Count);
PropertySpec property = classSpec.PublicProperties.First();
Assert.IsNotNull(property.Name);
Assert.IsNotNull(property.Name.Name);
Assert.IsNotNull(property.Name.Documentation);
Assert.IsNotNull(property.Type);
Assert.IsFalse(property.IsStatic);
}
static Settings()
{
TimerInterval = Configuration.GetRequiredValue <int>("TimerInterval");
AgencyId = Configuration.GetRequiredValue <int>("AgencyId");
WipeCarrierName = Configuration.GetRequiredValue("WipeCarrierName");
LastModifiedDate = Configuration.GetRequiredValue <DateTime>("LastModifiedDate");
CsvOutputFolderPath = Configuration.GetRequiredValue("CsvOutputFolderPath");
PDFInputFolderPath = Configuration.GetRequiredValue("PDFInputFolderPath");
ImportArchiveFolderPath = Configuration.GetRequiredValue("ImportArchiveFolderPath");
TextConverterProjectFolderPath = Configuration.GetRequiredValue("TextConverterProjectFolderPath");
ClassSpec = Configuration.GetRequiredValue("ClassSpec", ParseClassSpec);
}
public void FieldAndClassTest()
{
ClassSpec classSpec = NapackFileAnalyzer.Analyze("Test", "unused", SampleStrings.LargeSampleClass).Classes.First();
Assert.AreEqual(1, classSpec.PublicFields.Count);
FieldSpec field = classSpec.PublicFields.First();
Assert.IsNotNull(field.Name);
Assert.IsNotNull(field.Name.Name);
Assert.IsNotNull(field.Name.Documentation);
Assert.IsNotNull(field.Type);
Assert.IsTrue(field.IsConst);
Assert.IsFalse(field.IsStatic);
Assert.IsFalse(field.IsReadonly);
}
public BaseCharacter(ClassSpec @class = ClassSpec.WARRIOR, string name = "NoName",
int healthPoint = 100, int armour = 0, int attackPower = 0)
{
EquipedItems.Add("Weapon", new Items.Weapons.SteelSword());
EquipedItems.Add("Armour", new Items.Armours.SteelArmour());
EquipedItems.Add("Spell", new Items.Spells.Fireball());
EquipedItems.Add("Potion", new Items.Potion.HealthPotion());
Class = @class;
Name = name;
HealthPoint = healthPoint;
Armour = armour;
AttackPower = attackPower;
attackBehaviour = new CharactersActions.BasicAttack();
}
public void MethodAndClassTest()
{
ClassSpec classSpec = NapackFileAnalyzer.Analyze("Test", "unused", SampleStrings.LargeSampleClass).Classes.First();
Assert.IsTrue(classSpec.PublicMethods.Count != 0);
MethodSpec method = classSpec.PublicMethods.First();
foreach (ParameterSpec parameter in method.Parameters)
{
Assert.IsNotNull(parameter.Name);
Assert.IsNotNull(parameter.Modifier);
Assert.IsNotNull(parameter.Type);
}
Assert.IsNotNull(method.ReturnType);
}
/// <summary>
/// Determines the requried upversioning when code transitions from the old Napack to the new Napack.
/// </summary>
/// <remarks>
/// Major == breaking changes.
/// Minor == publically-facing API was added (but not changed or removed) from the new Napack.
/// Patch == The publically-facing API is identical between both Napacks, excluding documentation.
/// </remarks>
public static UpversionType DeterminedRequiredUpversioning(NapackSpec oldNapack, NapackSpec newNapack)
{
UpversionType maxUpversionType = UpversionType.Patch;
foreach (ClassSpec oldClassSpec in oldNapack.Classes)
{
ClassSpec newClassSpec = newNapack.Classes
.FirstOrDefault(cls => cls.Name.Name.Equals(oldClassSpec.Name.Name, StringComparison.InvariantCulture));
UpversionType upversionType = NapackAnalyst.AnalyzeClass(oldClassSpec, newClassSpec);
if (upversionType == UpversionType.Major)
{
// Exit early, as we found a breaking change.
return(UpversionType.Major);
}
else if (upversionType == UpversionType.Minor)
{
maxUpversionType = UpversionType.Minor;
}
}
foreach (InterfaceSpec oldInterfaceSpec in oldNapack.Interfaces)
{
InterfaceSpec newInterfaceSpec = newNapack.Interfaces
.FirstOrDefault(cls => cls.Name.Name.Equals(oldInterfaceSpec.Name.Name, StringComparison.InvariantCulture));
UpversionType upversionType = NapackAnalyst.AnalyzeInterface(oldInterfaceSpec, newInterfaceSpec);
if (upversionType == UpversionType.Major)
{
// Exit early, as we found a breaking change.
return(UpversionType.Major);
}
else if (upversionType == UpversionType.Minor)
{
maxUpversionType = UpversionType.Minor;
}
}
// No APIs added in the prior classes. Did the new package add classes?
if (maxUpversionType == UpversionType.Patch && (newNapack.Classes.Count != oldNapack.Classes.Count || newNapack.Interfaces.Count != oldNapack.Interfaces.Count))
{
maxUpversionType = UpversionType.Minor;
}
return(maxUpversionType);
}
// todo: this is _really_ bad logic, only works since lists don't change order
// LUA DRIVEN VARIANT
public static void ArrangeSpells2(this WeakAura weak, AuraGrid grid, ClassSpec spec, IEnumerable <Spell> spells)
{
foreach (var spell in spells)
{
var spellAuras = weak.AddSpell(spell, spec, 0, 0);
for (var i = 0; i < spellAuras.Count; i++)
{
var advance = i == spellAuras.Count - 1;
var aura = spellAuras[i];
var auraGrid = grid.LuaId;
var auraTalent = spell.Talent;
var auraClassSpec = (int)spec;
if (auraClassSpec != _auraClassSpec)
{
_sb.AddRecords(aura.Id, advance, auraGrid, auraTalent, auraClassSpec);
}
else if (auraTalent != _auraTalent)
{
_sb.AddRecords(aura.Id, advance, auraGrid, auraTalent);
}
else if (auraGrid != _auraGrid)
{
_sb.AddRecords(aura.Id, advance, auraGrid);
}
else if (advance)
{
_sb.AddRecords(aura.Id, advance);
}
else
{
_sb.AddRecords(aura.Id);
}
_auraGrid = auraGrid;
_auraTalent = auraTalent;
_auraClassSpec = auraClassSpec;
}
}
}
public static Hero GetInstance(ClassSpec classSpec)
{
if (instance == null)
{
switch (classSpec)
{
case ClassSpec.WARRIOR:
instance = new Hero(ClassSpec.WARRIOR, "HeroWarrior", 120, 0, 10);
break;
case ClassSpec.RANGER:
instance = new Hero(ClassSpec.RANGER, "HeroRanger", 100, 2, 5);
break;
case ClassSpec.MAGE:
instance = new Hero(ClassSpec.RANGER, "HeroMage", 80, 1, 2);
break;
}
}
return(instance);
}
public static string ToAuraPrefix(this ClassSpec classSpec)
{
return(classSpec switch
{
ClassSpec.FrostMage => "mage_frost",
ClassSpec.HolyPaladin => "paladin_holy",
ClassSpec.ProtectionPaladin => "paladin_protection",
ClassSpec.Retribution => "paladin_retribution",
ClassSpec.Arms => "warrior_arms",
ClassSpec.Fury => "warrior_fury",
ClassSpec.ProtectionWarrior => "warrior_protection",
ClassSpec.Balance => "druid_balance",
ClassSpec.Feral => "druid_feral",
ClassSpec.Guardian => "druid_guardian",
ClassSpec.RestorationDruid => "druid_restoration",
ClassSpec.Blood => "deathknight_blood",
ClassSpec.Frost => "deathknight_frost",
ClassSpec.Unholy => "deathknight_unholy",
ClassSpec.BeastMastery => "hunter_beastmastery",
ClassSpec.Marksmanship => "hunter_marksmanship",
ClassSpec.Survival => "hunter_survival",
ClassSpec.Discipline => "priest_discipline",
ClassSpec.HolyPriest => "priest_holy",
ClassSpec.Shadow => "priest_shadow",
ClassSpec.Assassination => "rogue_assassination",
ClassSpec.Outlaw => "rogue_outlaw",
ClassSpec.Subtlety => "rogue_subtlety",
ClassSpec.Elemental => "shaman_elemental",
ClassSpec.Enhancement => "shaman_enhancement",
ClassSpec.RestorationShaman => "shaman_restoration",
ClassSpec.Affliction => "warlock_affliction",
ClassSpec.Demonology => "warlock_demonology",
ClassSpec.Destruction => "warlock_destruction",
ClassSpec.Brewmaster => "monk_brewmaster",
ClassSpec.Windwalker => "monk_windwalker",
ClassSpec.Mistweaver => "monk_mistweaver",
ClassSpec.Havoc => "demonhunter_havoc",
ClassSpec.Vengeance => "demonhunter_vengeance",
_ => throw new ArgumentOutOfRangeException(nameof(classSpec), classSpec, null)
});
public void DocumentationIsParsed()
{
ClassSpec classSpec = NapackFileAnalyzer.Analyze("Test", "unused", SampleStrings.LargeSampleClass).Classes.First();
Assert.IsNotNull(classSpec.Name);
Assert.IsNotNull(classSpec.Name.Name);
Assert.IsNotNull(classSpec.Name.Documentation);
Assert.IsTrue(classSpec.PublicMethods.Count != 0);
MethodSpec method = classSpec.PublicMethods.First();
Assert.IsNotNull(method.Name);
Assert.IsNotNull(method.Name.Name);
Assert.IsNotNull(method.Name.Documentation);
Assert.IsTrue(classSpec.PublicConstructors.Count != 0);
ConstructorSpec constructor = classSpec.PublicConstructors.First();
Assert.IsNotNull(constructor.Name);
Assert.IsNotNull(constructor.Name.Name);
Assert.IsNotNull(constructor.Name.Documentation);
}
// OLD VARIANT
public static void ArrangeSpells(this WeakAura weak, AuraGrid grid, ClassSpec spec, IEnumerable <Spell> spells)
{
var talents = new List <int>();
var position = 0;
grid = grid.Clone();
grid.Reset();
foreach (var spell in spells)
{
weak.AddSpell(spell, spec, 0, 0);
var o = grid.Location?.Clone();
grid.Next();
var x = grid.Location.X;
var y = grid.Location.Y;
// Console.WriteLine($"{position}:: {x}, {y} -- {spell.Name} -- {y} - {grid.Origin.Y} < -{grid.Height} * {grid.Size}");
var spellAuras = weak.AddSpell(spell, spec, x, y);
if (talents.Any())
{
spellAuras.DisplaceByTalents(grid, position, talents.ToArray());
}
if (spell.Talent != 0)
{
talents.Add(spell.Talent);
grid.Location = o;
}
else
{
position++;
}
}
}
public void ConstructorAndClassTest()
{
ClassSpec classSpec = NapackFileAnalyzer.Analyze("Test", "unused", SampleStrings.LargeSampleClass).Classes.First();
Assert.IsTrue(classSpec.PublicConstructors.Count != 0);
ConstructorSpec constructor = classSpec.PublicConstructors.First();
bool oneHasDefault = false;
foreach (ParameterSpec parameter in constructor.Parameters)
{
Assert.IsNotNull(parameter.Name);
Assert.IsNotNull(parameter.Modifier);
Assert.IsNotNull(parameter.Type);
if (!string.IsNullOrWhiteSpace(parameter.Default))
{
oneHasDefault = true;
}
}
Assert.IsTrue(oneHasDefault);
}
public Enemy(int expReward, ClassSpec @class = ClassSpec.WARRIOR, string name = "NoName", int healthPoint = 100, int armour = 0, int attackPower = 0) : base(@class, name, healthPoint, armour, attackPower)
{
ExpReward = expReward;
maxHP = healthPoint;
}
public static List <Aura> AddSpell(this WeakAura weak, Spell spell, ClassSpec classSpec, int x, int y)
{
// todo: Use_Icon
var addedAuras = new List <Aura>();
var auraId = GenerateAuraId(classSpec, spell);
if (spell.Type.HasFlag(SpellType.Cooldown))
{
var aura = AuraIcon.Generate(auraId);
aura.WatchAbilityCooldown(spell.Name, spell.SpellIds);
addedAuras.Add(aura);
}
if (spell.Type.HasFlag(SpellType.DoT))
{
var onTarget = AuraIcon.Generate($"{auraId}_is_on_target");
onTarget.WatchForDebuffOnTarget(spell.Name);
var notOnTarget = AuraIcon.Generate($"{auraId}_not_on_target");
notOnTarget.WatchForDebuffNotOnTarget(spell.Name, spell.SpellIds);
notOnTarget.AddGlow(new Color(1, 0.04, 0.3));
var refreshable = spell.Durations.Count == 0 ? 0 : (int)Math.Floor(spell.Durations.Max() * 0.3);
if (refreshable < 1)
{
Console.WriteLine($"WARN: {spell.Name} refreshable very low: {refreshable};");
}
var canRefresh = AuraIcon.Generate($"{auraId}_refreshable");
canRefresh.AddGlow();
canRefresh.WatchForDebuffOnTargetLow(spell.Name, refreshable);
addedAuras.Add(onTarget, notOnTarget, canRefresh);
}
// DoT types already include a debuff on target tracker
else if (spell.Type.HasFlag(SpellType.DebuffOnTarget))
{
var onTarget = AuraIcon.Generate($"{auraId}_is_on_target");
onTarget.AddGlow();
if (spell.AssociatedAuras.Count != 0)
{
spell.AssociatedAuras.ForEach(s => onTarget.WatchForDebuffOnTarget(s.Name));
}
else
{
onTarget.WatchForDebuffOnTarget(spell.Name);
}
addedAuras.Add(onTarget);
}
if (spell.Type.HasFlag(SpellType.BuffOnPlayer))
{
var onPlayer = AuraIcon.Generate($"{auraId}_buff_on_me");
onPlayer.AddGlow();
if (spell.AssociatedAuras.Count != 0)
{
spell.AssociatedAuras.ForEach(s =>
{
if (s.Invert)
{
onPlayer.WatchForBuffNotOnPlayer(s.Name);
}
else
{
onPlayer.WatchForBuffOnPlayer(s.Name);
}
});
}
else
{
if (spell.Invert)
{
onPlayer.WatchForBuffNotOnPlayer(spell.Name);
}
else
{
onPlayer.WatchForBuffOnPlayer(spell.Name);
}
}
addedAuras.Add(onPlayer);
}
foreach (var aura in addedAuras)
{
weak.Table.Children.Add(aura);
aura.LoadIf(classSpec);
aura.LoadIfTalent(spell.Talent);
aura.AddVisibilityToggle();
aura.XOffset = x;
aura.YOffset = y;
if (spell.BigStacks)
{
// First SubRegion is always a TextRegion
aura.SubRegions.First().TextFontSize = 30;
}
}
return(addedAuras);
}
public Friend(ClassSpec @class = ClassSpec.WARRIOR, string name = "NoName", int healthPoint = 100, int armour = 0,
int attackPower = 0) : base(@class, name, healthPoint, armour, attackPower)
{
}
internal static ClassSpec AnalyzeClassSyntaxTree(string napackName, string filename, ClassDeclarationSyntax classNode)
{
ClassSpec classSpec = new ClassSpec();
classSpec.Name = DocumentedElement.LoadFromSyntaxNode(classNode);
classSpec.IsAbstract = classNode.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.AbstractKeyword));
classSpec.IsStatic = classNode.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.StaticKeyword));
classSpec.IsSealed = classSpec.IsStatic || classNode.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.SealedKeyword));
// Parse classes recursively
foreach (ClassDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.ClassDeclaration)))
{
if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) ||
(classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword))))
{
// This recursion will exit because we aren't *compiling* the code, but merely parsing it.
classSpec.PublicClasses.Add(AnalyzeClassSyntaxTree(napackName, filename, node));
}
}
// Parse methods
foreach (MethodDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.MethodDeclaration)))
{
if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) ||
(classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword))))
{
classSpec.PublicMethods.Add(MethodSpec.LoadFromSyntaxNode(node));
}
}
// Parse constructors
foreach (ConstructorDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.ConstructorDeclaration)))
{
if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) ||
(classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword))))
{
classSpec.PublicConstructors.Add(ConstructorSpec.LoadFromSyntaxNode(node));
}
}
// Parse fields
foreach (FieldDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.FieldDeclaration)))
{
if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) ||
(classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword))))
{
classSpec.PublicFields.Add(FieldSpec.LoadFromSyntaxNode(node));
}
}
// Parse properties
foreach (PropertyDeclarationSyntax node in classNode.ChildNodes().Where(node => node.IsKind(SyntaxKind.PropertyDeclaration)))
{
if (node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.PublicKeyword)) ||
(classSpec.ProtectedItemsConsideredPublic && node.Modifiers.Any(modifier => modifier.IsKind(SyntaxKind.ProtectedKeyword))))
{
classSpec.PublicProperties.Add(PropertySpec.LoadFromSyntaxNode(node));
}
}
return(classSpec);
}
public static void AutoDetectMyClassSpec()
{
ClassSpec currentSpec = WAECharacterSheet.ClassSpec;
switch (ObjectManager.Me.WowClass)
{
case (WoWClass.Warlock):
if (WTTalent.GetSpec() == 2)
{
WAECharacterSheet.ClassSpec = ClassSpec.WarlockDemonology;
}
else if (WTTalent.GetSpec() == 3)
{
WAECharacterSheet.ClassSpec = ClassSpec.WarlockDestruction;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.WarlockAffliction;
}
break;
case (WoWClass.DeathKnight):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.DeathKnightBloodDPS;
}
else if (WTTalent.GetSpec() == 2)
{
WAECharacterSheet.ClassSpec = ClassSpec.DeathKnightFrostDPS;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.DeathKnightUnholy;
}
break;
case (WoWClass.Druid):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.DruidBalance;
}
else if (WTTalent.GetSpec() == 3)
{
WAECharacterSheet.ClassSpec = ClassSpec.DruidRestoration;
}
else
{
// TBC FERAL
if (ToolBox.GetWoWVersion() == ToolBox.WoWVersion.TBC)
{
if (WTTalent.GetTalentRank(2, 7) > 0) // Feral Charge
{
WAECharacterSheet.ClassSpec = ClassSpec.DruidFeralTank;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.DruidFeralDPS;
}
}
// WOTLK FERAL
if (ToolBox.GetWoWVersion() == ToolBox.WoWVersion.WOTLK)
{
if (WTTalent.GetTalentRank(2, 5) > 2 || // Thick Hide
WTTalent.GetTalentRank(2, 16) > 0 || // Natural Reaction
WTTalent.GetTalentRank(2, 22) > 0) // Protector of the Pack
{
WAECharacterSheet.ClassSpec = ClassSpec.DruidFeralTank;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.DruidFeralDPS;
}
}
}
break;
case (WoWClass.Hunter):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.HunterBeastMastery;
}
else if (WTTalent.GetSpec() == 3)
{
WAECharacterSheet.ClassSpec = ClassSpec.HunterSurvival;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.HunterMarksman;
}
break;
case (WoWClass.Mage):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.MageArcane;
}
else if (WTTalent.GetSpec() == 2)
{
WAECharacterSheet.ClassSpec = ClassSpec.MageFire;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.MageFrost;
}
break;
case (WoWClass.Paladin):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.PaladinHoly;
}
else if (WTTalent.GetSpec() == 2)
{
WAECharacterSheet.ClassSpec = ClassSpec.PaladinProtection;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.PaladinRetribution;
}
break;
case (WoWClass.Priest):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.PriestDiscipline;
}
else if (WTTalent.GetSpec() == 2)
{
WAECharacterSheet.ClassSpec = ClassSpec.PriestHoly;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.PriestShadow;
}
break;
case (WoWClass.Rogue):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.RogueAssassination;
}
else if (WTTalent.GetSpec() == 3)
{
WAECharacterSheet.ClassSpec = ClassSpec.RogueSubtelty;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.RogueCombat;
}
break;
case (WoWClass.Shaman):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.ShamanElemental;
}
else if (WTTalent.GetSpec() == 3)
{
WAECharacterSheet.ClassSpec = ClassSpec.ShamanRestoration;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.ShamanEnhancement;
}
break;
case (WoWClass.Warrior):
if (WTTalent.GetSpec() == 1)
{
WAECharacterSheet.ClassSpec = ClassSpec.WarriorArms;
}
else if (WTTalent.GetSpec() == 3)
{
WAECharacterSheet.ClassSpec = ClassSpec.WarriorTank;
}
else
{
WAECharacterSheet.ClassSpec = ClassSpec.WarriorFury;
}
break;
default:
WAECharacterSheet.ClassSpec = ClassSpec.None;
break;
}
// Update stat weights in case of auto detect
if (AutoEquipSettings.CurrentSettings.AutoDetectStatWeights && currentSpec != WAECharacterSheet.ClassSpec)
{
WAEItemDB.ItemDb.Clear(); // to Rescan all items
SettingsPresets.ChangeStatsWeightSettings(WAECharacterSheet.ClassSpec);
}
// Set other default plugin settings according to detected class for first launch
if (AutoEquipSettings.CurrentSettings.FirstLaunch && currentSpec != WAECharacterSheet.ClassSpec)
{
Logger.Log("First Launch");
SettingsPresets.ChangeAutoEquipSetting(WAECharacterSheet.ClassSpec);
AutoEquipSettings.CurrentSettings.FirstLaunch = false;
AutoEquipSettings.CurrentSettings.Save();
}
AutoEquipSettings.CurrentSettings.SpecSelectedByUser = WAECharacterSheet.ClassSpec;
}
private void EmitProxy(ClassSpec classSpec)
{
var methods = new StringBuilder();
foreach (var methodSpec in classSpec.Methods)
{
var signature = new StringBuilder($"public {methodSpec.FullyQualifiedReturnTypeName} {methodSpec.Name}(");
var callArgs = new StringBuilder("");
var signatureArgs = new StringBuilder("");
var first = true;
foreach (var argumentSpec in methodSpec.Arguments)
{
if (!first)
{
signatureArgs.Append(", ");
}
first = false;
signatureArgs.Append($"{argumentSpec.FullyQualifiedTypeName} {argumentSpec.Name}");
callArgs.Append($", {argumentSpec.Name}");
}
signature.Append(signatureArgs);
signature.Append(')');
// Prepare method body
var body = "";
if (methodSpec.Support != SupportClassification.Supported)
{
body = methodSpec.SupportHint is null
? "throw new System.NotSupportedException();"
: $"throw new System.NotSupportedException(\"{methodSpec.SupportHint}\");";
}
else
{
// Get specific hub connection extension method call
var specificCall = GetSpecificCall(methodSpec);
// Handle ValueTask
var prefix = "";
var suffix = "";
if (methodSpec.IsReturnTypeValueTask)
{
if (methodSpec.InnerReturnTypeName is not null)
{
prefix = $"new System.Threading.Tasks.ValueTask<{methodSpec.InnerReturnTypeName}>(";
}
else
{
prefix = "new System.Threading.Tasks.ValueTask(";
}
suffix = $")";
}
// Bake it all together
body = $"return {prefix}this.connection.{specificCall}(\"{methodSpec.Name}\"{callArgs}){suffix};";
}
var method = $@"
{signature}
{{
{body}
}}
";
methods.Append(method);
}
var proxy = $@"// <auto-generated>
// Generated by Microsoft.AspNetCore.Client.SourceGenerator
// </auto-generated>
#nullable enable
using Microsoft.AspNetCore.SignalR.Client;
namespace {_spec.GetterNamespace}
{{
{_spec.GetterClassAccessibility} static partial class {_spec.GetterClassName}
{{
private sealed class {classSpec.ClassTypeName} : {classSpec.FullyQualifiedInterfaceTypeName}
{{
private readonly HubConnection connection;
internal {classSpec.ClassTypeName}(HubConnection connection)
{{
this.connection = connection;
}}
{methods.ToString()}
}}
}}
}}";
_context.AddSource($"HubServerProxy.{classSpec.ClassTypeName}.g.cs", SourceText.From(proxy.ToString(), Encoding.UTF8));
}
public SpellTalentSpec(Talent talent)
{
Talent = talent.TalentPosition();
Spec = (ClassSpec)talent.SpecId;
}
public EnemyOrcWarrior(int expReward = 99, ClassSpec @class = ClassSpec.WARRIOR, string name = "OrcsmerWarrior",
int healthPoint = 30, int armour = 2, int attackPower = 5)
: base(expReward, @class, name, healthPoint, armour, attackPower)
{
}
