Pixsaoul/TraitTracker
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update everything

Browse Source
This commit is contained in:
Pixsaoul
2024-09-23 01:27:01 +02:00
parent 4a6378dab0
commit 27f87cefda
10 changed files with 710 additions and 469 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
Assets/BitWise.cs
View File

@@ -29,14 +29,19 @@ public class BitWise
{ {
return result; return result;
} }
if(numberOfElementToSelect == 0)
{
result.Add(0);
return result;
}
long v = (1L << numberOfElementToSelect) - 1; long v = (1L << numberOfElementToSelect) - 1L;
long end = 1L << totalNumberOfElement; long end = 1L << totalNumberOfElement;
while (v < end) while (v < end)
{ {
result.Add(v); result.Add(v);
long t = (v | (v - 1)) + 1; long t = (v | (v - 1L)) + 1L;
v = t | ((((t & -t) / (v & -v)) >> 1) - 1); v = t | ((((t & -t) / (v & -v)) >> 1) - 1L);
} }
return result; return result;

6
Assets/Data/ChampionUtils.cs
View File

@@ -47,6 +47,12 @@ namespace Assets.Data
return BitWise.HammingWeight(champions); return BitWise.HammingWeight(champions);
} }
/// <summary>
/// 0 to n-1
/// </summary>
/// <param name="champions"></param>
/// <param name="n"></param>
/// <returns></returns>
public static long GetNthChampion(long champions, int n) public static long GetNthChampion(long champions, int n)
{ {
int kThFoundChampion = 0; int kThFoundChampion = 0;

54
Assets/Data/TraitSelectorManager.cs
View File

@@ -1,3 +1,4 @@
using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using Assets.Data; using Assets.Data;
using TMPro; using TMPro;
@@ -20,33 +21,50 @@ public class TraitSelectorManager : MonoBehaviour
[SerializeField] [SerializeField]
private int _traitThreshold = 7; private int _traitThreshold = 7;
private Dictionary<TraitsEnum, int> emblemList;
public void ListAllActivableCompo() public void ListAllActivableCompo()
{ {
emblemList = _emblemSelector.GetEmblems(); var emblemList = _emblemSelector.GetEmblems();
var mandatoryChampions = ChampionUtils.ToLong(_mandatorychampionSelector.GetSelectedChampions()); var mandatoryChampions = ChampionUtils.ToLong(_mandatorychampionSelector.GetSelectedChampions());
var acceptableChampions = ChampionUtils.ToLong(_acceptablechampionSelector.GetSelectedChampions()); var acceptableChampions = ChampionUtils.ToLong(_acceptablechampionSelector.GetSelectedChampions());
int compositionSize = _compositionSize.text == "" ? 1 : int.Parse(_compositionSize.text); int compositionSize = _compositionSize.text == "" ? 1 : int.Parse(_compositionSize.text);
var composition = TraitsMapping.GenerateCombinations(mandatoryChampions, acceptableChampions, compositionSize);
Coroutine coroutine = StartCoroutine(TraitsMapping.DisplayCompositions(composition)); Coroutine coroutine = StartCoroutine(ComputeCompositionAsync(mandatoryChampions, acceptableChampions, compositionSize, emblemList));
//var coroutine = StartCoroutine(TraitsMapping.GetChampionSubsetsAsync(champList, compositionSize,emblemList, HandleCombination)); }
public IEnumerator<float> ComputeCompositionAsync(long mandatoryChampions, long acceptableChampions, int compositionSize, Dictionary<int, int> emblemList)
{
var compositions = TraitsMapping.GenerateCombinations(mandatoryChampions, acceptableChampions, compositionSize);
Debug.Log($"{compositions.Count} Compositions generated.");
yield return 0f;
foreach (var composition in compositions)
{
HandleCombination(composition, emblemList);
yield return 0f;
}
} }
private void HandleCombination(long combination) private void HandleCombination(long combination, Dictionary<int, int> emblemList)
{ {
// var synergies = TraitsMapping.MergeEmblems( var synergies = TraitsMapping.TraitCountInCompo(combination);
// TraitsMapping.TraitCountInCompo(combination),
// emblemList var synergiesWithEmblem = TraitsMapping.MergeEmblems(
// ); synergies,
// var activeSynergies = TraitsMapping.FilterActiveTraits(synergies); emblemList
// if (TraitUtils.TraitCountFromInt(activeSynergies) >= _traitThreshold) );
// { var activeSynergies = TraitsMapping.FilterActiveTraits(synergiesWithEmblem);
// var s = TraitsMapping.CompositionToString(combination, activeSynergies);
// Debug.Log(s); if (TraitUtils.TraitCountFromInt(activeSynergies) >= _traitThreshold)
// } else { {
// Debug.LogWarning("Combination not valid"); HashSet<ChampionsEnum> champions = ChampionUtils.FromLong(combination);
// } var s = TraitsMapping.CompositionToString(champions);
Debug.Log(s);
}
// else
// {
// //Debug.LogWarning("Combination not valid");
// }
} }
} }

194
Assets/Data/TraitsMapping.cs
View File

@@ -826,14 +826,14 @@ namespace Assets.Data
}, },
}; };
public static Dictionary<int, int> minimalActivation = TraitsSteps.ToDictionary( public static int GetMinimalActivation(int trait)
kvp => kvp.Key, {
kvp => kvp.Value[0] return TraitsSteps[trait][0];
); }
public bool TraitEnabled(int trait, int traitChampCount) public bool TraitEnabled(int trait, int traitChampCount)
{ {
return traitChampCount >= minimalActivation[trait]; return traitChampCount >= GetMinimalActivation(trait);
} }
/// <summary> /// <summary>
@@ -844,24 +844,24 @@ namespace Assets.Data
public static Dictionary<int, int> TraitCountInCompo(long compo) public static Dictionary<int, int> TraitCountInCompo(long compo)
{ {
Dictionary<int, int> synergies = new Dictionary<int, int>(); Dictionary<int, int> synergies = new Dictionary<int, int>();
for (int i = 0; i < 64; i++) for (int i = 0; i < 60; i++)
{ {
if ((compo & (1L << i)) != 0) if ((compo & (1L << i)) != 0)
{ {
var champ = (long)i; var champ = (long)(1L << i);
var traits = ChampsTraits[champ]; var traits = ChampsTraits[champ];
// combine the traits within synergies using bitwise operation // combine the traits within synergies using bitwise operation
for (int trait = 0; trait < 22; trait++) for (int trait = 0; trait < 22; trait++)
{ {
if ((traits & (1 << trait)) != 0) if ((traits & (1 << trait)) != 0)
{ {
if (synergies.ContainsKey(trait)) if (synergies.ContainsKey(1 << trait))
{ {
synergies[trait]++; synergies[1 << trait]++;
} }
else else
{ {
synergies.Add(trait, 1); synergies.Add(1 << trait, 1);
} }
} }
} }
@@ -882,7 +882,7 @@ namespace Assets.Data
int output = 0; int output = 0;
foreach (var kvp in synergies) foreach (var kvp in synergies)
{ {
if (kvp.Value >= minimalActivation[kvp.Key]) if (kvp.Value >= GetMinimalActivation(kvp.Key))
{ {
output |= kvp.Key; output |= kvp.Key;
} }
@@ -910,11 +910,6 @@ namespace Assets.Data
return mergedEmblems; return mergedEmblems;
} }
void Start()
{
}
public void DisplayTraits(Dictionary<TraitsEnum, int> traits) public void DisplayTraits(Dictionary<TraitsEnum, int> traits)
{ {
@@ -934,139 +929,6 @@ namespace Assets.Data
return sb.ToString(); return sb.ToString();
} }
// public static IEnumerator GetChampionSubsetsAsync(
// long possibleChamp,
// long mandatoryChamps,
// int size,
// Dictionary<int, int> emblemList,
// System.Action<long> onCombinationGenerated
// )
// {
// List<long> possibleChampList = new List<long>();
// foreach (var champ in ChampsTraits.Keys)
// {
// if ((possibleChamp & champ) != 0)
// {
// possibleChampList.Add(champ);
// }
// }
// int n = possibleChampList.Count;
// }
/// <summary>
/// Create a list of compositions based on the possible champions, mandatory champions, size of the composition, and the list of emblems.
/// each composition much contain all mandatory champs, and can contain any number of possible champs.
/// No other champions are allowed in the composition.
/// Composition is stored in the shape of a long, where each bit represents a champion.
///
/// </summary>
/// <param name="possibleChamp"></param>
/// <param name="mandatoryChamps"></param>
/// <param name="size"></param>
/// <param name="emblemList"></param>
/// <param name="onCombinationGenerated"></param>
// /// <returns></returns>
// public static List<long> GetCompositionList(
// long possibleChamp,
// long mandatoryChamps,
// int size,
// Dictionary<int, int> emblemList,
// System.Action<long> onCombinationGenerated
// )
// {
// Dictionary<int,int> allTraits = emblemList;
// int alreadySelectionChampCount = mandatoryChamps.CountSetBits();
// }
public static List<HashSet<ChampionsEnum>> GetChampionSubsets(
HashSet<ChampionsEnum> champs,
int size
)
{
List<HashSet<ChampionsEnum>> result = new List<HashSet<ChampionsEnum>>();
if (size == 0)
{
result.Add(new HashSet<ChampionsEnum>());
return result;
}
List<ChampionsEnum> champList = champs.ToList();
// Handle the edge case when size is greater than the number of available champions.
if (size > champList.Count)
{
return result; // No valid subsets if size is too large.
}
// Use a bit mask approach to generate all subsets of the specified size.
int n = champList.Count;
int[] indices = new int[size];
for (int i = 0; i < size; i++)
indices[i] = i;
while (true)
{
HashSet<ChampionsEnum> subset = new HashSet<ChampionsEnum>();
foreach (int index in indices)
{
subset.Add(champList[index]);
}
result.Add(subset);
// Generate the next combination of indices
int i;
for (i = size - 1; i >= 0; i--)
{
if (indices[i] != i + n - size)
{
break;
}
}
if (i < 0)
{
break; // All combinations have been generated.
}
indices[i]++;
for (int j = i + 1; j < size; j++)
{
indices[j] = indices[j - 1] + 1;
}
}
return result;
}
public static List<HashSet<ChampionsEnum>> GetChampionSubsetsRec(
HashSet<ChampionsEnum> champs,
int size
)
{
List<HashSet<ChampionsEnum>> result = new List<HashSet<ChampionsEnum>>();
if (size == 0)
{
result.Add(new HashSet<ChampionsEnum>());
return result;
}
if (champs.Count == 0)
{
return result;
}
ChampionsEnum first = champs.First();
HashSet<ChampionsEnum> rest = new HashSet<ChampionsEnum>(champs);
rest.Remove(first);
List<HashSet<ChampionsEnum>> subResult = GetChampionSubsetsRec(rest, size - 1);
foreach (var set in subResult)
{
set.Add(first);
}
result.AddRange(subResult);
result.AddRange(GetChampionSubsetsRec(rest, size));
return result;
}
public static int MaxIntForCombinationOfn(int n) public static int MaxIntForCombinationOfn(int n)
{ {
@@ -1117,21 +979,8 @@ namespace Assets.Data
HashSet<long> combinations = BitWise.GetAllPermutation(champToSelectCount, possibleChampCount); HashSet<long> combinations = BitWise.GetAllPermutation(champToSelectCount, possibleChampCount);
foreach (var combinationOfPossibleChamps in combinations) foreach (var combinationOfPossibleChamps in combinations)
{ {
// generating one composition based on the combination. var composition = SelectSublistOfChampion(possibleChamps, combinationOfPossibleChamps);
// combination 10010 will add the second and fifth champion of the possibleChamps list to the composition. composition |= mandatoryChamps;
long composition = mandatoryChamps;
int possibleChampIterator = 0;
int kThChampFound = 0;
while (possibleChampIterator < champToSelectCount)
{
if ((combinationOfPossibleChamps & (1 << possibleChampIterator)) != 0)
{
long champ = ChampionUtils.GetNthChampion(possibleChamps,kThChampFound);
composition |= champ;
kThChampFound++;
}
possibleChampIterator++;
}
compositions.Add(composition); compositions.Add(composition);
} }
return compositions; return compositions;
@@ -1149,5 +998,22 @@ namespace Assets.Data
yield return null; 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);
}
} }
} }

2
Assets/Scenes/SampleScene.unity
View File

@@ -3273,7 +3273,7 @@ MonoBehaviour:
_mandatorychampionSelector: {fileID: 479329100} _mandatorychampionSelector: {fileID: 479329100}
_acceptablechampionSelector: {fileID: 1418508558} _acceptablechampionSelector: {fileID: 1418508558}
_emblemSelector: {fileID: 1032725645} _emblemSelector: {fileID: 1032725645}
_traitThreshold: 7 _traitThreshold: 5
--- !u!114 &1418508558 stripped --- !u!114 &1418508558 stripped
MonoBehaviour: MonoBehaviour:
m_CorrespondingSourceObject: {fileID: 8148431447111668956, guid: c027171600fc2d34e89847fce2ced78b, type: 3} m_CorrespondingSourceObject: {fileID: 8148431447111668956, guid: c027171600fc2d34e89847fce2ced78b, type: 3}

17
Assets/Tests/Editor/TestBitWise.cs
View File

@@ -36,7 +36,7 @@ namespace Assets.Data
0b01101, 0b01101,
0b10011, 0b10011,
0b01011, 0b01011,
0b00111, 7,
} }
); );
yield return new TestCaseData( yield return new TestCaseData(
@@ -47,6 +47,21 @@ namespace Assets.Data
0b001 0b001
} }
); );
yield return new TestCaseData(
0,
1,
new HashSet<long>()
{
0b0
}
);
yield return new TestCaseData(
3,
1,
new HashSet<long>()
{
}
);
yield return new TestCaseData( yield return new TestCaseData(
2, 2,
3, 3,

146
Assets/Tests/Editor/TestTraitsMapping.cs
View File

@@ -31,6 +31,18 @@ namespace Assets.Data
Assert.IsTrue(expected.Contains(champ)); Assert.IsTrue(expected.Contains(champ));
} }
} }
[Test]
[TestCaseSource(typeof(TraitsMappingCase), "TestFilteringChampCombination")]
public void TestFilteringChampCombination(
long accessibleChampions,
long subselectedChampions,
long expected
)
{
var output = TraitsMapping.SelectSublistOfChampion(accessibleChampions, subselectedChampions);
Assert.AreEqual(expected, output);
}
} }
public class TraitsMappingCase public class TraitsMappingCase
@@ -76,7 +88,7 @@ namespace Assets.Data
ChampionsEnum.ELISE, ChampionsEnum.ELISE,
ChampionsEnum.AHRI, ChampionsEnum.AHRI,
ChampionsEnum.CASSIOPEIA, ChampionsEnum.CASSIOPEIA,
ChampionsEnum.EZREAL ChampionsEnum.EZREAL,
} }
), ),
5, 5,
@@ -89,7 +101,7 @@ namespace Assets.Data
ChampionsEnum.BLITZCRANK, ChampionsEnum.BLITZCRANK,
ChampionsEnum.ELISE, ChampionsEnum.ELISE,
ChampionsEnum.AHRI, ChampionsEnum.AHRI,
ChampionsEnum.CASSIOPEIA ChampionsEnum.CASSIOPEIA,
} }
), ),
ChampionUtils.ToLong( ChampionUtils.ToLong(
@@ -99,7 +111,7 @@ namespace Assets.Data
ChampionsEnum.BLITZCRANK, ChampionsEnum.BLITZCRANK,
ChampionsEnum.ELISE, ChampionsEnum.ELISE,
ChampionsEnum.AHRI, ChampionsEnum.AHRI,
ChampionsEnum.EZREAL ChampionsEnum.EZREAL,
} }
), ),
ChampionUtils.ToLong( ChampionUtils.ToLong(
@@ -109,7 +121,7 @@ namespace Assets.Data
ChampionsEnum.BLITZCRANK, ChampionsEnum.BLITZCRANK,
ChampionsEnum.ELISE, ChampionsEnum.ELISE,
ChampionsEnum.CASSIOPEIA, ChampionsEnum.CASSIOPEIA,
ChampionsEnum.EZREAL ChampionsEnum.EZREAL,
} }
), ),
ChampionUtils.ToLong( ChampionUtils.ToLong(
@@ -119,19 +131,28 @@ namespace Assets.Data
ChampionsEnum.BLITZCRANK, ChampionsEnum.BLITZCRANK,
ChampionsEnum.AHRI, ChampionsEnum.AHRI,
ChampionsEnum.CASSIOPEIA, ChampionsEnum.CASSIOPEIA,
ChampionsEnum.EZREAL ChampionsEnum.EZREAL,
} }
), ),
} }
); );
yield return new TestCaseData( yield return new TestCaseData(
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>() { ChampionsEnum.AHRI, ChampionsEnum.AKALI }
),
ChampionUtils.ToLong(new HashSet<ChampionsEnum>() { ChampionsEnum.ELISE }), ChampionUtils.ToLong(new HashSet<ChampionsEnum>() { ChampionsEnum.ELISE }),
ChampionUtils.ToLong(new HashSet<ChampionsEnum>() { ChampionsEnum.AHRI }), 3,
1,
new List<long>() new List<long>()
{ {
ChampionUtils.ToLong(new HashSet<ChampionsEnum>() { ChampionsEnum.ELISE }), ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.AHRI,
ChampionsEnum.AKALI,
ChampionsEnum.ELISE,
}
),
} }
); );
@@ -142,11 +163,15 @@ namespace Assets.Data
ChampionsEnum.AHRI, ChampionsEnum.AHRI,
ChampionsEnum.POPPY, ChampionsEnum.POPPY,
ChampionsEnum.SORAKA, ChampionsEnum.SORAKA,
ChampionsEnum.HWEI, ChampionsEnum.XERATH,
} }
), ),
ChampionUtils.ToLong( ChampionUtils.ToLong(
new HashSet<ChampionsEnum>() { ChampionsEnum.SMOLDER, ChampionsEnum.XERATH } new HashSet<ChampionsEnum>()
{
ChampionsEnum.SMOLDER,
ChampionsEnum.MORDEKAISER,
}
), ),
4, 4,
new List<long>() new List<long>()
@@ -157,12 +182,111 @@ namespace Assets.Data
ChampionsEnum.AHRI, ChampionsEnum.AHRI,
ChampionsEnum.POPPY, ChampionsEnum.POPPY,
ChampionsEnum.SORAKA, ChampionsEnum.SORAKA,
ChampionsEnum.HWEI, ChampionsEnum.XERATH,
}
),
}
);
yield return new TestCaseData(
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.RUMBLE,
ChampionsEnum.GALIO,
ChampionsEnum.AKALI,
ChampionsEnum.BARD,
}
),
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.MORGANA,
ChampionsEnum.FIORA,
ChampionsEnum.VARUS,
}
),
7,
new List<long>()
{
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.RUMBLE,
ChampionsEnum.GALIO,
ChampionsEnum.AKALI,
ChampionsEnum.BARD,
ChampionsEnum.MORGANA,
ChampionsEnum.FIORA,
ChampionsEnum.VARUS
}
),
}
);
yield return new TestCaseData(
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.RUMBLE,
ChampionsEnum.GALIO,
ChampionsEnum.AKALI,
ChampionsEnum.BARD,
ChampionsEnum.MORGANA,
ChampionsEnum.FIORA,
ChampionsEnum.VARUS
}
),
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.XERATH
}
),
7,
new List<long>()
{
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.RUMBLE,
ChampionsEnum.GALIO,
ChampionsEnum.AKALI,
ChampionsEnum.BARD,
ChampionsEnum.MORGANA,
ChampionsEnum.FIORA,
ChampionsEnum.VARUS
} }
), ),
} }
); );
} }
} }
public static IEnumerable TestFilteringChampCombination
{
get
{
yield return new TestCaseData(
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.ASHE,
ChampionsEnum.BLITZCRANK,
ChampionsEnum.ELISE,
ChampionsEnum.JAX
}
),
0b0101,
ChampionUtils.ToLong(
new HashSet<ChampionsEnum>()
{
ChampionsEnum.ASHE,
ChampionsEnum.ELISE
}
)
);
}
}
} }
} }

50
Assets/UI/UIToLogic.cs → Assets/UI/EmblemSelector.cs
View File

@@ -78,32 +78,32 @@ public class EmblemSelector : MonoBehaviour
// Start is called before the first frame update // Start is called before the first frame update
void Start() { } void Start() { }
public Dictionary<TraitsEnum, int> GetEmblems() public Dictionary<int, int> GetEmblems()
{ {
Dictionary<TraitsEnum, int> emblems = new Dictionary<TraitsEnum, int>(); Dictionary<int, int> emblems = new Dictionary<int, int>();
emblems[TraitsEnum.ARCANA] = int.Parse(_arcanaEmblems.text); emblems[(int)TraitsEnum.ARCANA] = int.Parse(_arcanaEmblems.text);
emblems[TraitsEnum.CHRONO] = int.Parse(_chronoEmblems.text); emblems[(int)TraitsEnum.CHRONO] = int.Parse(_chronoEmblems.text);
emblems[TraitsEnum.DRAGON] = int.Parse(_dragonEmblems.text); emblems[(int)TraitsEnum.DRAGON] = int.Parse(_dragonEmblems.text);
emblems[TraitsEnum.DRUID] = int.Parse(_druidEmblems.text); emblems[(int)TraitsEnum.DRUID] = int.Parse(_druidEmblems.text);
emblems[TraitsEnum.ELDRICHT] = int.Parse(_eldrichtEmblems.text); emblems[(int)TraitsEnum.ELDRICHT] = int.Parse(_eldrichtEmblems.text);
emblems[TraitsEnum.FAERIE] = int.Parse(_faerieEmblems.text); emblems[(int)TraitsEnum.FAERIE] = int.Parse(_faerieEmblems.text);
emblems[TraitsEnum.FROST] = int.Parse(_frostEmblems.text); emblems[(int)TraitsEnum.FROST] = int.Parse(_frostEmblems.text);
emblems[TraitsEnum.HONEYMANCY] = int.Parse(_honeymancyEmblems.text); emblems[(int)TraitsEnum.HONEYMANCY] = int.Parse(_honeymancyEmblems.text);
emblems[TraitsEnum.PORTAL] = int.Parse(_portalEmblems.text); emblems[(int)TraitsEnum.PORTAL] = int.Parse(_portalEmblems.text);
emblems[TraitsEnum.PYRO] = int.Parse(_pyroEmblems.text); emblems[(int)TraitsEnum.PYRO] = int.Parse(_pyroEmblems.text);
emblems[TraitsEnum.SUGARCRAFT] = int.Parse(_sugarcraftEmblems.text); emblems[(int)TraitsEnum.SUGARCRAFT] = int.Parse(_sugarcraftEmblems.text);
emblems[TraitsEnum.WITCHCRAFT] = int.Parse(_witchcraftEmblems.text); emblems[(int)TraitsEnum.WITCHCRAFT] = int.Parse(_witchcraftEmblems.text);
emblems[TraitsEnum.BASTION] = int.Parse(_bastionEmblems.text); emblems[(int)TraitsEnum.BASTION] = int.Parse(_bastionEmblems.text);
emblems[TraitsEnum.BLASTER] = int.Parse(_blasterEmblems.text); emblems[(int)TraitsEnum.BLASTER] = int.Parse(_blasterEmblems.text);
emblems[TraitsEnum.HUNTER] = int.Parse(_hunterEmblems.text); emblems[(int)TraitsEnum.HUNTER] = int.Parse(_hunterEmblems.text);
emblems[TraitsEnum.INCANTATOR] = int.Parse(_incantatorEmblems.text); emblems[(int)TraitsEnum.INCANTATOR] = int.Parse(_incantatorEmblems.text);
emblems[TraitsEnum.MAGE] = int.Parse(_mageEmblems.text); emblems[(int)TraitsEnum.MAGE] = int.Parse(_mageEmblems.text);
emblems[TraitsEnum.MULTISTRIKER] = int.Parse(_multistrikerEmblems.text); emblems[(int)TraitsEnum.MULTISTRIKER] = int.Parse(_multistrikerEmblems.text);
emblems[TraitsEnum.PRESERVER] = int.Parse(_preserverEmblems.text); emblems[(int)TraitsEnum.PRESERVER] = int.Parse(_preserverEmblems.text);
emblems[TraitsEnum.SCHOLAR] = int.Parse(_scholarEmblems.text); emblems[(int)TraitsEnum.SCHOLAR] = int.Parse(_scholarEmblems.text);
emblems[TraitsEnum.SHAPESHIFTER] = int.Parse(_shapeshifterEmblems.text); emblems[(int)TraitsEnum.SHAPESHIFTER] = int.Parse(_shapeshifterEmblems.text);
emblems[TraitsEnum.VANGUARD] = int.Parse(_vanguardEmblems.text); emblems[(int)TraitsEnum.VANGUARD] = int.Parse(_vanguardEmblems.text);
emblems[TraitsEnum.WARRIOR] = int.Parse(_warriorEmblems.text); emblems[(int)TraitsEnum.WARRIOR] = int.Parse(_warriorEmblems.text);
return emblems; return emblems;
} }
public void Reset() public void Reset()

0
Assets/UI/UIToLogic.cs.meta → Assets/UI/EmblemSelector.cs.meta
View File

697
UserSettings/Layouts/default-2023.dwlt
View File

File diff suppressed because it is too large Load Diff