~~ "lib" is a list of spell available, "take" is the hardcoded number of spell to keep ~~
var firstBetterSpellNoGroup = lib.Where(item => item.Group == 0)
.GroupBy(item => new { item.SpellType, item.Target, item.IsAoE, item.IsInstantCast, item.HasSubSpell })
.Select(ins => ins.OrderByDescending(it => it.Level).ThenByDescending(it => it.ID).Take(take));
var firstBetterSpellGroup = lib.Where(item => item.Group != 0)
.GroupBy(item => item.Group)
.Select(ins => ins.OrderByDescending(it => it.Level).ThenByDescending(it => it.ID).Take(take));
// sort by reverse level for multiple version
var firstBetterSpellFinal = firstBetterSpellGroup.SelectMany(el => el).Union(firstBetterSpellNoGroup.SelectMany(el => el))
.Where(item => item != null).OrderByDescending(item => item.Level).ToList();
// Get Appearance Order
// not group base
var baseOrderNoGroup = lib.Where(item => item.Group == 0)
.GroupBy(item => new { item.SpellType, item.Target, item.IsAoE, item.IsInstantCast, item.HasSubSpell })
.Select(ins => ins.OrderBy(it => it.Level).ThenBy(it => it.ID).Take(take));
// group based
var baseOrderGroup = lib.Where(item => item.Group != 0)
.GroupBy(item => item.Group)
.Select(ins => ins.OrderBy(it => it.Level).ThenBy(it => it.ID).Take(take));
// Join and sort...
var baseOrderFinal = baseOrderNoGroup.SelectMany(el => el).Union(baseOrderGroup.SelectMany(el => el))
.Where(item => item != null).OrderBy(item => item.Level).ThenBy(item => item.ID).ToList();
int countbase = 0;
while (countbase < baseOrderFinal.Count)
{
// replace each spell of order with their best equivalent
Spell sp = baseOrderFinal[countbase];
Spell find = firstBetterSpellFinal.Where(od => ((od.Group == 0 && sp.Group == 0)
&& (od.SpellType == sp.SpellType
&& od.Target == sp.Target
&& od.IsAoE == sp.IsAoE
&& od.HasSubSpell == sp.HasSubSpell
&& od.IsInstantCast == sp.IsInstantCast))
|| (od.Group != 0 && od.Group == sp.Group)).FirstOrDefault();
if (find != null)
{
baseOrderFinal[countbase] = find;
firstBetterSpellFinal.Remove(find);
countbase++;
}
else
{
baseOrderFinal.RemoveAt(countbase);
}
}
/// <summary>
/// Get Summarized "Hybrid" Spell Dictionary
/// List Caster use basic Specialization Getter...
/// This would have pretty much no reason to be used by GameLiving... (Maybe as a shortcut to force them to use their best spells...)
/// </summary>
/// <param name="living"></param>
/// <returns></returns>
protected override IDictionary<SpellLine, List<Skill>> GetLinesSpellsForLiving(GameLiving living, int level)
{
// An hybrid dictionary is composed of a spellline "base"
// SpecLine and Baseline are mixed in spellline named "base"
// baseline are displayed first (improvement are easier this way)
// specline are displayed secondly (ordered in appareance order)
// some class/spelline are allowed to display the "2 -best" spell
// this is hardcoded in AllowMultipleSpellVersions...
Dictionary<SpellLine, List<Skill>> buffer = new Dictionary<SpellLine, List<Skill>>();
List<SpellLine> lines = GetSpellLinesForLiving(living, level);
foreach (SpellLine ls in lines)
{
// buffer shouldn't contain duplicate lines
if (buffer.ContainsKey(ls))
continue;
// Add to Dictionary
List<Skill> finalList;
finalList = new List<Skill>();
buffer.Add(ls, finalList);
IEnumerable<Spell> lib = SkillBase.GetSpellList(ls.KeyName).Where(item => item.Level <= ls.Level);
int take = 1;
if ((living is GamePlayer) && AllowMultipleSpellVersions(ls, (GamePlayer)living))
{
// Get 2-First Better Spell for each type
take = 2;
}
IEnumerable<IEnumerable<Spell>> firstBetterSpellNoGroup = lib.Where(item => item.Group == 0)
.GroupBy(item => new { item.SpellType, item.Target, item.IsAoE, item.IsInstantCast, item.HasSubSpell })
.Select(ins => ins.OrderByDescending(it => it.Level).ThenByDescending(it => it.ID).Take(take));
IEnumerable<IEnumerable<Spell>> firstBetterSpellGroup = lib.Where(item => item.Group != 0)
.GroupBy(item => item.Group)
.Select(ins => ins.OrderByDescending(it => it.Level).ThenByDescending(it => it.ID).Take(take));
// sort by reverse level for multiple version
List<Spell> firstBetterSpellFinal = firstBetterSpellGroup.SelectMany(el => el).Union(firstBetterSpellNoGroup.SelectMany(el => el))
.Where(item => item != null).OrderByDescending(item => item.Level).ToList();
// Get Appearance Order
// not group base
IEnumerable<IEnumerable<Spell>> baseOrderNoGroup = lib.Where(item => item.Group == 0)
.GroupBy(item => new { item.SpellType, item.Target, item.IsAoE, item.IsInstantCast, item.HasSubSpell })
.Select(ins => ins.OrderBy(it => it.Level).ThenBy(it => it.ID).Take(take));
// group based
IEnumerable<IEnumerable<Spell>> baseOrderGroup = lib.Where(item => item.Group != 0)
.GroupBy(item => item.Group)
.Select(ins => ins.OrderBy(it => it.Level).ThenBy(it => it.ID).Take(take));
// Join and sort...
IEnumerable<Spell> baseOrderFinal = baseOrderNoGroup.SelectMany(el => el).Union(baseOrderGroup.SelectMany(el => el))
.Where(item => item != null).OrderBy(item => item.Level).ThenBy(item => item.ID);
foreach (Spell sp in baseOrderFinal)
{
// replace each spell of order with their best equivalent
int index = firstBetterSpellFinal.FindIndex(od => ((od.Group == 0 && sp.Group == 0)
&& (od.SpellType == sp.SpellType
&& od.Target == sp.Target
&& od.IsAoE == sp.IsAoE
&& od.HasSubSpell == sp.HasSubSpell
&& od.IsInstantCast == sp.IsInstantCast))
|| (od.Group != 0 && od.Group == sp.Group));
if (index > -1)
{
finalList.Add(firstBetterSpellFinal[index]);
firstBetterSpellFinal.RemoveAt(index);
}
}
}
return buffer;
}
Return to “%s” DOL Development Discussion
Users browsing this forum: No registered users and 1 guest