1107 lines
39 KiB
C#
1107 lines
39 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using NUnit.Framework;
|
|
using UnityEngine;
|
|
|
|
namespace Set.Data
|
|
{
|
|
public class TraitsMapping : MonoBehaviour
|
|
{
|
|
// long for champion, int for traits
|
|
public static int TotalChampionCout = 63;
|
|
public static int TotalTraitCount = 25;
|
|
public static Dictionary<long, int> ChampsTraits = new Dictionary<long, int>
|
|
{
|
|
// Cost 1 Champions
|
|
{
|
|
(long)ChampionsEnum.AATROX,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MIGHTYMECH, TraitsEnum.HEAVYWEIGHT, TraitsEnum.JUGGERNAUT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.EZREAL,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.BATTLEACADEMIA, TraitsEnum.PRODIGY }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.GAREN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.BATTLEACADEMIA, TraitsEnum.BASTION }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.GNAR,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.LUCHADOR, TraitsEnum.SNIPER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KALISTA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SOULFIGHTER, TraitsEnum.EXECUTIONER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KAYLE,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.WRAITH, TraitsEnum.DUELIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KENNEN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SUPREMECELLS, TraitsEnum.PROTECTOR, TraitsEnum.SORCERER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.LUCIAN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MIGHTYMECH, TraitsEnum.SORCERER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.MALPHITE,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.THECREW, TraitsEnum.PROTECTOR }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.NAAFIRI,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SOULFIGHTER, TraitsEnum.JUGGERNAUT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.RELL,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.STARGUARDIAN, TraitsEnum.BASTION }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SIVIR,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.THECREW, TraitsEnum.SNIPER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SYNDRA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.CRYSTALGAMBIT, TraitsEnum.STARGUARDIAN, TraitsEnum.PRODIGY }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.ZAC,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.WRAITH, TraitsEnum.HEAVYWEIGHT }
|
|
)
|
|
},
|
|
|
|
// Cost 2 Champions
|
|
{
|
|
(long)ChampionsEnum.DRMUNDO,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.LUCHADOR, TraitsEnum.JUGGERNAUT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.GANGPLANK,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MIGHTYMECH, TraitsEnum.DUELIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.JANNA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.CRYSTALGAMBIT, TraitsEnum.PROTECTOR, TraitsEnum.STRATEGIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.JHIN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.WRAITH, TraitsEnum.SNIPER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KAISA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SUPREMECELLS, TraitsEnum.DUELIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KATARINA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.BATTLEACADEMIA, TraitsEnum.EXECUTIONER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KOBUKO,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MENTOR, TraitsEnum.HEAVYWEIGHT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.LUX,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SOULFIGHTER, TraitsEnum.SORCERER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.RAKAN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.BATTLEACADEMIA, TraitsEnum.PROTECTOR }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SHEN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.THECREW, TraitsEnum.BASTION, TraitsEnum.EDGELORD }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.VI,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.CRYSTALGAMBIT, TraitsEnum.JUGGERNAUT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.XAYAH,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.STARGUARDIAN, TraitsEnum.EDGELORD }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.XINZHAO,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SOULFIGHTER, TraitsEnum.BASTION }
|
|
)
|
|
},
|
|
|
|
// Cost 3 Champions
|
|
{
|
|
(long)ChampionsEnum.AHRI,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.STARGUARDIAN, TraitsEnum.SORCERER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.CAITLYN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.BATTLEACADEMIA, TraitsEnum.SNIPER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.DARIUS,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SUPREMECELLS, TraitsEnum.HEAVYWEIGHT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.JAYCE,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.BATTLEACADEMIA, TraitsEnum.HEAVYWEIGHT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KOGMAW,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MONSTERTRAINER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.LULU,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MONSTERTRAINER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.MALZAHAR,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.WRAITH, TraitsEnum.PRODIGY }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.NEEKO,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.STARGUARDIAN, TraitsEnum.PROTECTOR }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.RAMMUS,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MONSTERTRAINER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SENNA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MIGHTYMECH, TraitsEnum.EXECUTIONER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SMOLDER,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MONSTERTRAINER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SWAIN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.CRYSTALGAMBIT, TraitsEnum.BASTION, TraitsEnum.SORCERER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.UDYR,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MENTOR, TraitsEnum.JUGGERNAUT, TraitsEnum.DUELIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.VIEGO,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SOULFIGHTER, TraitsEnum.DUELIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.YASUO,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MENTOR, TraitsEnum.EDGELORD }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.ZIGGS,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.THECREW, TraitsEnum.STRATEGIST }
|
|
)
|
|
},
|
|
|
|
// Cost 4 Champions
|
|
{
|
|
(long)ChampionsEnum.AKALI,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SUPREMECELLS, TraitsEnum.EXECUTIONER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.ASHE,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.CRYSTALGAMBIT, TraitsEnum.DUELIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.JARVANIV,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MIGHTYMECH, TraitsEnum.STRATEGIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.JINX,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.STARGUARDIAN, TraitsEnum.SNIPER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KARMA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MIGHTYMECH, TraitsEnum.SORCERER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.KSANTE,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.WRAITH, TraitsEnum.PROTECTOR }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.LEONA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.BATTLEACADEMIA, TraitsEnum.BASTION }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.POPPY,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.STARGUARDIAN, TraitsEnum.HEAVYWEIGHT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.RYZE,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.MENTOR, TraitsEnum.EXECUTIONER, TraitsEnum.STRATEGIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SAMIRA,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SOULFIGHTER, TraitsEnum.EDGELORD }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SETT,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SOULFIGHTER, TraitsEnum.JUGGERNAUT }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.VOLIBEAR,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.LUCHADOR, TraitsEnum.EDGELORD }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.YUUMI,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.BATTLEACADEMIA, TraitsEnum.PRODIGY }
|
|
)
|
|
},
|
|
|
|
// Cost 5 Champions
|
|
{
|
|
(long)ChampionsEnum.BRAUM,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.THECHAMP, TraitsEnum.LUCHADOR, TraitsEnum.BASTION }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.EKKO,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.PRODIGY, TraitsEnum.SORCERER, TraitsEnum.STRATEGIST }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.GWEN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.SOULFIGHTER, TraitsEnum.SORCERER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.LEESIN,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.STANCEMASTER, TraitsEnum.DUELIST, TraitsEnum.JUGGERNAUT, TraitsEnum.EXECUTIONER }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.SERAPHINE,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.STARGUARDIAN, TraitsEnum.PRODIGY }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.TWISTEDFATE,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.ROGUECAPTAIN, TraitsEnum.THECREW }
|
|
)
|
|
},
|
|
{
|
|
(long)ChampionsEnum.VARUS,
|
|
TraitUtils.ToInt(
|
|
new HashSet<TraitsEnum> { TraitsEnum.WRAITH, TraitsEnum.SNIPER }
|
|
)
|
|
},
|
|
};
|
|
|
|
public static Dictionary<int, long> TraitsChamp = new Dictionary<int, long>
|
|
{
|
|
{
|
|
(int)TraitsEnum.BATTLEACADEMIA,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.EZREAL,
|
|
ChampionsEnum.GAREN,
|
|
ChampionsEnum.KATARINA,
|
|
ChampionsEnum.RAKAN,
|
|
ChampionsEnum.CAITLYN,
|
|
ChampionsEnum.JAYCE,
|
|
ChampionsEnum.LEONA,
|
|
ChampionsEnum.YUUMI,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.CRYSTALGAMBIT,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.SYNDRA,
|
|
ChampionsEnum.JANNA,
|
|
ChampionsEnum.VI,
|
|
ChampionsEnum.ASHE,
|
|
ChampionsEnum.SWAIN,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.LUCHADOR,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.GNAR,
|
|
ChampionsEnum.DRMUNDO,
|
|
ChampionsEnum.BRAUM,
|
|
ChampionsEnum.VOLIBEAR,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.MIGHTYMECH,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.AATROX,
|
|
ChampionsEnum.LUCIAN,
|
|
ChampionsEnum.GANGPLANK,
|
|
ChampionsEnum.SENNA,
|
|
ChampionsEnum.JARVANIV,
|
|
ChampionsEnum.KARMA,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.MONSTERTRAINER,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KOGMAW,
|
|
ChampionsEnum.LULU,
|
|
ChampionsEnum.RAMMUS,
|
|
ChampionsEnum.SMOLDER,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.SOULFIGHTER,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KALISTA,
|
|
ChampionsEnum.NAAFIRI,
|
|
ChampionsEnum.LUX,
|
|
ChampionsEnum.XINZHAO,
|
|
ChampionsEnum.VIEGO,
|
|
ChampionsEnum.SAMIRA,
|
|
ChampionsEnum.SETT,
|
|
ChampionsEnum.GWEN,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.STARGUARDIAN,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.RELL,
|
|
ChampionsEnum.SYNDRA,
|
|
ChampionsEnum.XAYAH,
|
|
ChampionsEnum.AHRI,
|
|
ChampionsEnum.NEEKO,
|
|
ChampionsEnum.JINX,
|
|
ChampionsEnum.POPPY,
|
|
ChampionsEnum.SERAPHINE,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.SUPREMECELLS,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KENNEN,
|
|
ChampionsEnum.KAISA,
|
|
ChampionsEnum.DARIUS,
|
|
ChampionsEnum.AKALI,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.THECREW,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.MALPHITE,
|
|
ChampionsEnum.SIVIR,
|
|
ChampionsEnum.SHEN,
|
|
ChampionsEnum.ZIGGS,
|
|
ChampionsEnum.TWISTEDFATE,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.WRAITH,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KAYLE,
|
|
ChampionsEnum.ZAC,
|
|
ChampionsEnum.JHIN,
|
|
ChampionsEnum.MALZAHAR,
|
|
ChampionsEnum.KSANTE,
|
|
ChampionsEnum.VARUS,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.MENTOR,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KOBUKO,
|
|
ChampionsEnum.UDYR,
|
|
ChampionsEnum.YASUO,
|
|
ChampionsEnum.RYZE,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.PRODIGY,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.EZREAL,
|
|
ChampionsEnum.SYNDRA,
|
|
ChampionsEnum.MALZAHAR,
|
|
ChampionsEnum.YUUMI,
|
|
ChampionsEnum.EKKO,
|
|
ChampionsEnum.SERAPHINE,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.THECHAMP,
|
|
ChampionUtils.ToLong(new HashSet<ChampionsEnum>() { ChampionsEnum.BRAUM })
|
|
},
|
|
{
|
|
(int)TraitsEnum.STANCEMASTER,
|
|
ChampionUtils.ToLong(new HashSet<ChampionsEnum>() { ChampionsEnum.LEESIN })
|
|
},
|
|
{
|
|
(int)TraitsEnum.ROGUECAPTAIN,
|
|
ChampionUtils.ToLong(new HashSet<ChampionsEnum>() { ChampionsEnum.TWISTEDFATE })
|
|
},
|
|
{
|
|
(int)TraitsEnum.BASTION,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.GAREN,
|
|
ChampionsEnum.RELL,
|
|
ChampionsEnum.SHEN,
|
|
ChampionsEnum.XINZHAO,
|
|
ChampionsEnum.SWAIN,
|
|
ChampionsEnum.LEONA,
|
|
ChampionsEnum.BRAUM,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.DUELIST,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KAYLE,
|
|
ChampionsEnum.GANGPLANK,
|
|
ChampionsEnum.KAISA,
|
|
ChampionsEnum.ASHE,
|
|
ChampionsEnum.UDYR,
|
|
ChampionsEnum.VIEGO,
|
|
ChampionsEnum.LEESIN,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.EDGELORD,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.SHEN,
|
|
ChampionsEnum.XAYAH,
|
|
ChampionsEnum.YASUO,
|
|
ChampionsEnum.SAMIRA,
|
|
ChampionsEnum.VOLIBEAR,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.EXECUTIONER,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KALISTA,
|
|
ChampionsEnum.KATARINA,
|
|
ChampionsEnum.AKALI,
|
|
ChampionsEnum.RYZE,
|
|
ChampionsEnum.SENNA,
|
|
ChampionsEnum.LEESIN,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.HEAVYWEIGHT,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.AATROX,
|
|
ChampionsEnum.ZAC,
|
|
ChampionsEnum.KOBUKO,
|
|
ChampionsEnum.DARIUS,
|
|
ChampionsEnum.JAYCE,
|
|
ChampionsEnum.POPPY,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.JUGGERNAUT,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.AATROX,
|
|
ChampionsEnum.NAAFIRI,
|
|
ChampionsEnum.DRMUNDO,
|
|
ChampionsEnum.VI,
|
|
ChampionsEnum.UDYR,
|
|
ChampionsEnum.SETT,
|
|
ChampionsEnum.LEESIN,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.PROTECTOR,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KENNEN,
|
|
ChampionsEnum.MALPHITE,
|
|
ChampionsEnum.JANNA,
|
|
ChampionsEnum.RAKAN,
|
|
ChampionsEnum.NEEKO,
|
|
ChampionsEnum.KSANTE,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.SNIPER,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.GNAR,
|
|
ChampionsEnum.SIVIR,
|
|
ChampionsEnum.JHIN,
|
|
ChampionsEnum.CAITLYN,
|
|
ChampionsEnum.JINX,
|
|
ChampionsEnum.VARUS,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.SORCERER,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.KENNEN,
|
|
ChampionsEnum.LUCIAN,
|
|
ChampionsEnum.LUX,
|
|
ChampionsEnum.AHRI,
|
|
ChampionsEnum.SWAIN,
|
|
ChampionsEnum.KARMA,
|
|
ChampionsEnum.EKKO,
|
|
ChampionsEnum.GWEN,
|
|
}
|
|
)
|
|
},
|
|
{
|
|
(int)TraitsEnum.STRATEGIST,
|
|
ChampionUtils.ToLong(
|
|
new HashSet<ChampionsEnum>()
|
|
{
|
|
ChampionsEnum.JANNA,
|
|
ChampionsEnum.ZIGGS,
|
|
ChampionsEnum.JARVANIV,
|
|
ChampionsEnum.RYZE,
|
|
ChampionsEnum.EKKO,
|
|
}
|
|
)
|
|
},
|
|
};
|
|
|
|
public Dictionary<long, int> ChampionCost = new Dictionary<long, int>()
|
|
{
|
|
// Cost 1 Champions
|
|
{ (long)ChampionsEnum.AATROX, 1 },
|
|
{ (long)ChampionsEnum.EZREAL, 1 },
|
|
{ (long)ChampionsEnum.GAREN, 1 },
|
|
{ (long)ChampionsEnum.GNAR, 1 },
|
|
{ (long)ChampionsEnum.KALISTA, 1 },
|
|
{ (long)ChampionsEnum.KAYLE, 1 },
|
|
{ (long)ChampionsEnum.KENNEN, 1 },
|
|
{ (long)ChampionsEnum.LUCIAN, 1 },
|
|
{ (long)ChampionsEnum.MALPHITE, 1 },
|
|
{ (long)ChampionsEnum.NAAFIRI, 1 },
|
|
{ (long)ChampionsEnum.RELL, 1 },
|
|
{ (long)ChampionsEnum.SIVIR, 1 },
|
|
{ (long)ChampionsEnum.SYNDRA, 1 },
|
|
{ (long)ChampionsEnum.ZAC, 1 },
|
|
|
|
// Cost 2 Champions
|
|
{ (long)ChampionsEnum.DRMUNDO, 2 },
|
|
{ (long)ChampionsEnum.GANGPLANK, 2 },
|
|
{ (long)ChampionsEnum.JANNA, 2 },
|
|
{ (long)ChampionsEnum.JHIN, 2 },
|
|
{ (long)ChampionsEnum.KAISA, 2 },
|
|
{ (long)ChampionsEnum.KATARINA, 2 },
|
|
{ (long)ChampionsEnum.KOBUKO, 2 },
|
|
{ (long)ChampionsEnum.LUX, 2 },
|
|
{ (long)ChampionsEnum.RAKAN, 2 },
|
|
{ (long)ChampionsEnum.SHEN, 2 },
|
|
{ (long)ChampionsEnum.VI, 2 },
|
|
{ (long)ChampionsEnum.XAYAH, 2 },
|
|
{ (long)ChampionsEnum.XINZHAO, 2 },
|
|
|
|
// Cost 3 Champions
|
|
{ (long)ChampionsEnum.AHRI, 3 },
|
|
{ (long)ChampionsEnum.CAITLYN, 3 },
|
|
{ (long)ChampionsEnum.DARIUS, 3 },
|
|
{ (long)ChampionsEnum.JAYCE, 3 },
|
|
{ (long)ChampionsEnum.KOGMAW, 3 },
|
|
{ (long)ChampionsEnum.LULU, 3 },
|
|
{ (long)ChampionsEnum.MALZAHAR, 3 },
|
|
{ (long)ChampionsEnum.NEEKO, 3 },
|
|
{ (long)ChampionsEnum.RAMMUS, 3 },
|
|
{ (long)ChampionsEnum.SENNA, 3 },
|
|
{ (long)ChampionsEnum.SMOLDER, 3 },
|
|
{ (long)ChampionsEnum.SWAIN, 3 },
|
|
{ (long)ChampionsEnum.UDYR, 3 },
|
|
{ (long)ChampionsEnum.VIEGO, 3 },
|
|
{ (long)ChampionsEnum.YASUO, 3 },
|
|
{ (long)ChampionsEnum.ZIGGS, 3 },
|
|
|
|
// Cost 4 Champions
|
|
{ (long)ChampionsEnum.AKALI, 4 },
|
|
{ (long)ChampionsEnum.ASHE, 4 },
|
|
{ (long)ChampionsEnum.JARVANIV, 4 },
|
|
{ (long)ChampionsEnum.JINX, 4 },
|
|
{ (long)ChampionsEnum.KARMA, 4 },
|
|
{ (long)ChampionsEnum.KSANTE, 4 },
|
|
{ (long)ChampionsEnum.LEONA, 4 },
|
|
{ (long)ChampionsEnum.POPPY, 4 },
|
|
{ (long)ChampionsEnum.RYZE, 4 },
|
|
{ (long)ChampionsEnum.SAMIRA, 4 },
|
|
{ (long)ChampionsEnum.SETT, 4 },
|
|
{ (long)ChampionsEnum.VOLIBEAR, 4 },
|
|
{ (long)ChampionsEnum.YUUMI, 4 },
|
|
|
|
// Cost 5 Champions
|
|
{ (long)ChampionsEnum.BRAUM, 5 },
|
|
{ (long)ChampionsEnum.EKKO, 5 },
|
|
{ (long)ChampionsEnum.GWEN, 5 },
|
|
{ (long)ChampionsEnum.LEESIN, 5 },
|
|
{ (long)ChampionsEnum.SERAPHINE, 5 },
|
|
{ (long)ChampionsEnum.TWISTEDFATE, 5 },
|
|
{ (long)ChampionsEnum.VARUS, 5 },
|
|
};
|
|
|
|
public static Dictionary<int, List<int>> TraitsSteps = new Dictionary<int, List<int>>
|
|
{
|
|
{
|
|
(int)TraitsEnum.BATTLEACADEMIA,
|
|
new List<int> { 3, 5, 7 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.CRYSTALGAMBIT,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.LUCHADOR,
|
|
new List<int> { 2, 4 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.MIGHTYMECH,
|
|
new List<int> { 3, 5, 7 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.MONSTERTRAINER,
|
|
new List<int> { 1 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.SOULFIGHTER,
|
|
new List<int> { 2, 4, 6, 8 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.STARGUARDIAN,
|
|
new List<int> { 2, 3, 4, 5, 6, 7, 8, 9, 10 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.SUPREMECELLS,
|
|
new List<int> { 2, 3, 4 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.THECREW,
|
|
new List<int> { 2, 3, 4, 5 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.WRAITH,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.MENTOR,
|
|
new List<int> { 1, 4 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.PRODIGY,
|
|
new List<int> { 2, 3, 4, 5 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.THECHAMP,
|
|
new List<int> { 1 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.STANCEMASTER,
|
|
new List<int> { 1 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.ROGUECAPTAIN,
|
|
new List<int> { 1 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.BASTION,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.DUELIST,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.EDGELORD,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.EXECUTIONER,
|
|
new List<int> { 2, 3, 4, 5 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.HEAVYWEIGHT,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.JUGGERNAUT,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.PROTECTOR,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.SNIPER,
|
|
new List<int> { 2, 3, 4, 5 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.SORCERER,
|
|
new List<int> { 2, 4, 6 }
|
|
},
|
|
{
|
|
(int)TraitsEnum.STRATEGIST,
|
|
new List<int> { 2, 3, 4, 5 }
|
|
},
|
|
};
|
|
|
|
public static int GetMinimalActivation(int trait)
|
|
{
|
|
return TraitsSteps[trait][0];
|
|
}
|
|
|
|
public bool TraitEnabled(int trait, int traitChampCount)
|
|
{
|
|
return traitChampCount >= GetMinimalActivation(trait);
|
|
}
|
|
|
|
/// <summary>
|
|
/// first int is the trait, second int is the number of champions with this trait
|
|
/// </summary>
|
|
/// <param name="compo"></param>
|
|
/// <returns></returns>
|
|
public static Dictionary<int, int> TraitCountInCompo(long compo)
|
|
{
|
|
Dictionary<int, int> synergies = new Dictionary<int, int>();
|
|
for (int i = 0; i < TotalChampionCout; i++)
|
|
{
|
|
if ((compo & (1L << i)) != 0)
|
|
{
|
|
var champ = (long)(1L << i);
|
|
var traits = ChampsTraits[champ];
|
|
// combine the traits within synergies using bitwise operation
|
|
for (int trait = 0; trait < TotalTraitCount; trait++)
|
|
{
|
|
if ((traits & (1 << trait)) != 0)
|
|
{
|
|
if (synergies.ContainsKey(1 << trait))
|
|
{
|
|
synergies[1 << trait]++;
|
|
}
|
|
else
|
|
{
|
|
synergies.Add(1 << trait, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return synergies;
|
|
}
|
|
|
|
/// <summary>
|
|
/// first int is trait, second int is the number of champions with this trait
|
|
/// output is int of the flag of active traits
|
|
/// </summary>
|
|
/// <param name="synergies"></param>
|
|
/// <returns></returns>
|
|
public static int FilterActiveTraits(Dictionary<int, int> synergies)
|
|
{
|
|
int output = 0;
|
|
foreach (var kvp in synergies)
|
|
{
|
|
if (kvp.Value >= GetMinimalActivation(kvp.Key))
|
|
{
|
|
output |= kvp.Key;
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
|
|
/// <summary>
|
|
/// trait is the trait, count is the number of champions with this trait
|
|
/// </summary>
|
|
/// <param name="synergies"></param>
|
|
/// <param name="additionalEmblems"></param>
|
|
/// <returns></returns>
|
|
public static Dictionary<int, int> MergeEmblems(
|
|
Dictionary<int, int> synergies,
|
|
Dictionary<int, int> additionalEmblems
|
|
)
|
|
{
|
|
Dictionary<int, int> mergedEmblems = new Dictionary<int, int>();
|
|
|
|
mergedEmblems = synergies
|
|
.Concat(additionalEmblems)
|
|
.GroupBy(x => x.Key)
|
|
.ToDictionary(x => x.Key, x => x.Sum(y => y.Value));
|
|
return mergedEmblems;
|
|
}
|
|
|
|
public void DisplayTraits(Dictionary<TraitsEnum, int> traits)
|
|
{
|
|
foreach (var kvp in traits)
|
|
{
|
|
Debug.Log($"{kvp.Key} : {kvp.Value}");
|
|
}
|
|
}
|
|
|
|
public string DisplayComposition(HashSet<ChampionsEnum> compo)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
foreach (var champ in compo)
|
|
{
|
|
sb.Append(champ.ToString() + " / ");
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
public static int MaxIntForCombinationOfn(int n)
|
|
{
|
|
return (1 << n) - 1;
|
|
}
|
|
|
|
internal static string CompositionToString(HashSet<ChampionsEnum> composition)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
foreach (var champ in composition)
|
|
{
|
|
sb.Append(champ.ToString() + " / ");
|
|
}
|
|
sb.Append(" --------- ");
|
|
// HashSet<TraitsEnum> activeSynergies = FilterActiveTraits(ChampionUtils.ToLong(composition)));
|
|
// foreach (var trait in activeSynergies)
|
|
// {
|
|
// sb.Append(trait.ToString() + " / ");
|
|
// }
|
|
return sb.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// I have a list of champion that are fixed, in a long called mandatoryChamps.
|
|
/// I have a list of champions that are possible, in a long called possibleChamps.
|
|
/// I want to generate all possible combinations of champions that contain all mandatory champions.
|
|
/// I can use MaxIntForCombinationOfn to get the maximum number of possible combinations and iterate over all possible combination,
|
|
/// each bit of the combination will represent the nth champion in the list of possible champions, which is not a list but a long.
|
|
/// The composition will be composed of all the mandatory champs and some of the possible champs, to add up to the composition size exactly.
|
|
/// </summary>
|
|
/// <param name="composition"></param>
|
|
/// <param name="activeSynergies"></param>
|
|
/// <returns></returns>
|
|
///
|
|
public static List<long> GenerateCombinations(
|
|
long mandatoryChamps,
|
|
long possibleChamps,
|
|
int compositionSize
|
|
)
|
|
{
|
|
possibleChamps = possibleChamps & ~mandatoryChamps;
|
|
|
|
Assert.IsTrue((mandatoryChamps & possibleChamps) == 0);
|
|
|
|
List<long> compositions = new List<long>();
|
|
int champToSelectCount =
|
|
compositionSize - ChampionUtils.NumberOfChampions(mandatoryChamps);
|
|
int possibleChampCount = ChampionUtils.NumberOfChampions(possibleChamps);
|
|
Assert.IsTrue(champToSelectCount >= 0); // else we have too many mandatory champs
|
|
HashSet<long> combinations = BitWise.GetAllPermutation(
|
|
champToSelectCount,
|
|
possibleChampCount
|
|
);
|
|
foreach (var combinationOfPossibleChamps in combinations)
|
|
{
|
|
var composition = SelectSublistOfChampion(
|
|
possibleChamps,
|
|
combinationOfPossibleChamps
|
|
);
|
|
composition |= mandatoryChamps;
|
|
compositions.Add(composition);
|
|
}
|
|
return compositions;
|
|
}
|
|
|
|
public static IEnumerator DisplayCompositions(List<long> compositions)
|
|
{
|
|
Debug.Log("Number of compositions : " + compositions.Count);
|
|
yield return null;
|
|
foreach (var compo in compositions)
|
|
{
|
|
Debug.Log(CompositionToString(ChampionUtils.FromLong(compo)));
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
public static long SelectSublistOfChampion(
|
|
long accessibleChampions,
|
|
long subselectedChampions
|
|
)
|
|
{
|
|
var champs = ChampionUtils.FromLong(accessibleChampions).ToList<ChampionsEnum>();
|
|
// this list of champ is ordered. I want to filter this with the subselectedChampions bit flag
|
|
// where all bit to 1 are the champions I want to keep, and all bit to 0 are the champions I want to remove
|
|
HashSet<ChampionsEnum> selectedChamps = new HashSet<ChampionsEnum>();
|
|
|
|
for (int i = 0; i < champs.Count; i++)
|
|
{
|
|
if ((subselectedChampions & (1L << i)) != 0)
|
|
{
|
|
selectedChamps.Add(champs[i]);
|
|
}
|
|
}
|
|
return ChampionUtils.ToLong(selectedChamps);
|
|
}
|
|
}
|
|
}
|