public bool IsUnlocked(StaticGameDataDefinition definition, ProgressionUnlockCategory category)
{
bool flag = false;
for (int i = 0; i <= Level; i++)
{
if (unlockDefinitions.Length > i && unlockDefinitions[i].ContainsKey(category) && Array.IndexOf(unlockDefinitions[i][category].Definitions, definition) != -1)
{
flag = true;
break;
}
}
if (rewardDefinitions.ContainsKey(category))
{
if (!flag && rewardDefinitions[category].Contains(definition))
{
flag = true;
}
}
else
{
Log.LogErrorFormatted(this, "Category {0} was not found in Reward Definitions.", category);
}
return(flag);
}
public UnlockDefinition GetUnlockedDefinitionsForLevel(int level, ProgressionUnlockCategory category)
{
level = normalizeLevel(level);
if (unlockDefinitions.Length > level && unlockDefinitions[level].ContainsKey(category))
{
return(unlockDefinitions[level][category]);
}
return(default(UnlockDefinition));
}
public int GetUnlockedCountsForLevel(int level, ProgressionUnlockCategory category)
{
level = normalizeLevel(level);
if (unlockCounts[level].ContainsKey(category))
{
return(unlockCounts[level][category]);
}
return(0);
}
public string[] GetUnlockedIDsForLevel(int level, ProgressionUnlockCategory category)
{
level = normalizeLevel(level);
if (unlockItems[level].ContainsKey(category))
{
return(unlockItems[level][category]);
}
return(new string[0]);
}
public int GetUnlockLevelFromDefinition(StaticGameDataDefinition definition, ProgressionUnlockCategory category)
{
int result = -1;
for (int i = 0; i <= MaxUnlockLevel; i++)
{
if (unlockDefinitions.Length > i && unlockDefinitions[i].ContainsKey(category) && Array.IndexOf(unlockDefinitions[i][category].Definitions, definition) != -1)
{
result = i;
break;
}
}
return(result);
}
public bool IsUnlocked(int count, ProgressionUnlockCategory category)
{
for (int i = 0; i <= Level; i++)
{
if (unlockCounts[i].ContainsKey(category))
{
count -= unlockCounts[i][category];
}
}
if (rewardCounts.ContainsKey(category))
{
count -= rewardCounts[category];
}
return(count <= 0);
}
public int GetUnlockedCountsForCategory(ProgressionUnlockCategory category)
{
int num = 0;
for (int i = 0; i <= Level; i++)
{
if (unlockCounts[i].ContainsKey(category))
{
num += unlockCounts[i][category];
}
}
if (rewardCounts.ContainsKey(category))
{
num += rewardCounts[category];
}
return(num);
}
public string[] GetUnlockedIDsForCategory(ProgressionUnlockCategory category)
{
List <string> list = new List <string>();
for (int i = 0; i <= Level; i++)
{
if (unlockItems[i].ContainsKey(category))
{
list.AddRange(unlockItems[i][category]);
}
}
if (rewardItems.ContainsKey(category))
{
list.AddRange(rewardItems[category]);
}
return(list.ToArray());
}
public bool IsUnlocked(string unlockID, ProgressionUnlockCategory category)
{
bool flag = false;
for (int i = 0; i <= Level; i++)
{
if (Array.IndexOf(unlockItems[i][category], unlockID) != -1)
{
flag = true;
break;
}
}
if (!flag && rewardItems[category].Contains(unlockID))
{
flag = true;
}
return(flag);
}
public T[] GetUnlockedDefinitionsForCategory <T>(ProgressionUnlockCategory category) where T : StaticGameDataDefinition
{
List <T> list = new List <T>();
int level = Level;
for (int i = 0; i <= level; i++)
{
if (unlockDefinitions.Length > i && unlockDefinitions[i].ContainsKey(category))
{
list.AddRange(unlockDefinitions[i][category].Definitions as T[]);
}
}
if (rewardDefinitions.ContainsKey(category))
{
foreach (T item in rewardDefinitions[category])
{
list.Add(item);
}
}
return(list.ToArray());
}
public bool IsUnlocked(object definitionID, ProgressionUnlockCategory category)
{
for (int i = 0; i <= Level; i++)
{
if (unlockDefinitions.Length <= i || !unlockDefinitions[i].ContainsKey(category) || unlockDefinitions[i][category].Definitions.Length <= 0)
{
continue;
}
StaticGameDataDefinition[] definitions = unlockDefinitions[i][category].Definitions;
FieldInfo attributedField = StaticGameDataDefinitionIdAttribute.GetAttributedField(definitions[0].GetType());
for (int j = 0; j < definitions.Length; j++)
{
if (attributedField.GetValue(definitions[j]).Equals(definitionID))
{
return(true);
}
}
}
if (rewardDefinitions.ContainsKey(category) && rewardDefinitions[category].Count > 0)
{
HashSet <StaticGameDataDefinition> hashSet = rewardDefinitions[category];
HashSet <StaticGameDataDefinition> .Enumerator enumerator = hashSet.GetEnumerator();
enumerator.MoveNext();
FieldInfo attributedField = StaticGameDataDefinitionIdAttribute.GetAttributedField(enumerator.Current.GetType());
if (attributedField.GetValue(enumerator.Current).Equals(definitionID))
{
return(true);
}
while (enumerator.MoveNext())
{
if (attributedField.GetValue(enumerator.Current).Equals(definitionID))
{
return(true);
}
}
}
return(false);
}
public static bool IsItemOwned(DisneyStoreItemData item)
{
List <DReward> rewards = item.GetRewards();
for (int i = 0; i < rewards.Count; i++)
{
if (rewards[i].Category == RewardCategory.equipmentInstances)
{
if (!InventoryUtils.IsCustomEquipmentOwned(rewards[i].EquipmentRequest))
{
return(false);
}
}
else if (Enum.IsDefined(typeof(ProgressionUnlockCategory), rewards[i].Category.ToString()))
{
ProgressionUnlockCategory category = (ProgressionUnlockCategory)Enum.Parse(typeof(ProgressionUnlockCategory), rewards[i].Category.ToString());
if (!Service.Get <ProgressionService>().IsUnlocked(rewards[i].UnlockID, category))
{
return(false);
}
}
}
return(true);
}
private void addRewardItem(string identifier, object item)
{
if (item == null)
{
return;
}
ProgressionUnlockCategory?progressionUnlockCategory = ProgressionUtils.RewardToProgressionCategory(identifier);
if (!progressionUnlockCategory.HasValue)
{
return;
}
ProgressionUnlockCategory value = progressionUnlockCategory.Value;
if (typeof(IList).IsAssignableFrom(item.GetType()))
{
IList list = (IList)item;
if (list == null)
{
return;
}
FieldInfo field = typeof(ProgressionUnlockDefinition).GetField(identifier);
if (field.FieldType.IsArray)
{
Type elementType = field.FieldType.GetElementType();
FieldInfo attributedField = StaticGameDataDefinitionIdAttribute.GetAttributedField(elementType);
if (attributedField == null)
{
Log.LogErrorFormatted(this, "The type {0} did not contain a field with the StaticGameDataDefinitionId attribute", elementType.Name);
return;
}
Type fieldType = attributedField.FieldType;
Type type = typeof(Dictionary <, >).MakeGenericType(fieldType, elementType);
IDictionary dictionary = (IDictionary)Service.Get <GameData>().Get(type);
List <StaticGameDataDefinition> list2 = new List <StaticGameDataDefinition>();
for (int i = 0; i < list.Count; i++)
{
StaticGameDataDefinition staticGameDataDefinition = dictionary[list[i]] as StaticGameDataDefinition;
if (staticGameDataDefinition != null)
{
list2.Add(staticGameDataDefinition);
}
}
if (rewardDefinitions.ContainsKey(value))
{
rewardDefinitions[value].UnionWith(list2);
}
else
{
rewardDefinitions[value] = new HashSet <StaticGameDataDefinition>(list2);
}
}
else if (rewardItems.ContainsKey(value))
{
rewardItems[value].UnionWith((List <string>)list);
}
else
{
rewardItems[value] = new HashSet <string>((List <string>)list);
}
}
else
{
if (item.GetType() != typeof(int))
{
return;
}
int num = (int)item;
if (num > 0)
{
if (rewardCounts.ContainsKey(value))
{
rewardCounts[value] += num;
}
else
{
rewardCounts[value] = num;
}
}
}
}
public static List <ParsedProgression <TDefinition> > RetrieveProgressionLockedItems <TDefinition, TReward>(ProgressionUnlockCategory category, Func <List <TReward>, TDefinition[]> getRewards) where TDefinition : StaticGameDataDefinition, IMemberLocked where TReward : AbstractStaticGameDataRewardDefinition <TDefinition>
{
ProgressionService progressionService = Service.Get <ProgressionService>();
TDefinition[] unlockedDefinitionsForCategory = progressionService.GetUnlockedDefinitionsForCategory <TDefinition>(category);
HashSet <TDefinition> hashSet = new HashSet <TDefinition>(unlockedDefinitionsForCategory);
int level = progressionService.Level;
List <ParsedProgression <TDefinition> > list = new List <ParsedProgression <TDefinition> >();
int lastUnlockedIndex = -1;
bool isLocalPlayerMember = Service.Get <CPDataEntityCollection>().IsLocalPlayerMember();
for (int i = 0; i <= progressionService.MaxUnlockLevel; i++)
{
TDefinition[] array = progressionService.GetUnlockedDefinitionsForLevel(i, category).Definitions as TDefinition[];
if (array == null || array.Length <= 0)
{
continue;
}
bool flag = i > level;
for (int j = 0; j < array.Length; j++)
{
if ((UnityEngine.Object)array[j] != (UnityEngine.Object)null)
{
ParsedProgression <TDefinition> parsedProgression = new ParsedProgression <TDefinition>(array[j], i, null, flag, progressionLocked: false, array[j].IsMemberOnly);
addParsedProgression(list, parsedProgression, flag, isLocalPlayerMember, ref lastUnlockedIndex);
if (hashSet.Contains(array[j]))
{
hashSet.Remove(array[j]);
}
}
}
}
QuestService questService = Service.Get <QuestService>();
Dictionary <string, Mascot> questToMascotMap = questService.QuestToMascotMap;
foreach (QuestDefinition knownQuest in questService.KnownQuests)
{
questToMascotMap.TryGetValue(knownQuest.name, out var value);
if (value == null)
{
continue;
}
string name = value.Name;
questService.GetQuest(knownQuest);
if (knownQuest.StartReward != null)
{
parseRewardDefinition(list, getRewards(knownQuest.StartReward.GetDefinitions <TReward>()), hashSet, progressionService, category, name, ref lastUnlockedIndex);
}
if (knownQuest.CompleteReward != null)
{
parseRewardDefinition(list, getRewards(knownQuest.CompleteReward.GetDefinitions <TReward>()), hashSet, progressionService, category, name, ref lastUnlockedIndex);
}
if (knownQuest.ObjectiveRewards != null)
{
for (int j = 0; j < knownQuest.ObjectiveRewards.Length; j++)
{
parseRewardDefinition(list, getRewards(knownQuest.ObjectiveRewards[j].GetDefinitions <TReward>()), hashSet, progressionService, category, name, ref lastUnlockedIndex);
}
}
}
if (hashSet.Count > 0)
{
TDefinition[] array2 = new TDefinition[hashSet.Count];
hashSet.CopyTo(array2);
for (int j = 0; j < array2.Length; j++)
{
ParsedProgression <TDefinition> parsedProgression = new ParsedProgression <TDefinition>(array2[j], -1, null, levelLocked: false, progressionLocked: false, array2[j].IsMemberOnly);
lastUnlockedIndex++;
list.Insert(lastUnlockedIndex, parsedProgression);
}
}
return(list);
}
private static void parseRewardDefinition <T>(List <ParsedProgression <T> > parsedProgressionList, T[] unlocks, HashSet <T> progressionUnlockedRewards, ProgressionService progressionService, ProgressionUnlockCategory category, string mascotName, ref int lastUnlockedIndex) where T : StaticGameDataDefinition, IMemberLocked
{
if (unlocks == null || unlocks.Length <= 0)
{
return;
}
bool flag = false;
bool isLocalPlayerMember = Service.Get <CPDataEntityCollection>().IsLocalPlayerMember();
for (int i = 0; i < unlocks.Length; i++)
{
if ((UnityEngine.Object)unlocks[i] != (UnityEngine.Object)null)
{
if (!progressionService.IsUnlocked(unlocks[i], category))
{
flag = true;
}
ParsedProgression <T> parsedProgression = new ParsedProgression <T>(unlocks[i], -1, mascotName, levelLocked: false, flag, unlocks[i].IsMemberOnly);
addParsedProgression(parsedProgressionList, parsedProgression, flag, isLocalPlayerMember, ref lastUnlockedIndex);
if (progressionUnlockedRewards.Contains(unlocks[i]))
{
progressionUnlockedRewards.Remove(unlocks[i]);
}
}
}
}
