private HashSet <string> FakeUpdateReachableTransitions(string newThing = null, ProgressionManager _pm = null)
{
if (_pm != null)
{
pm = _pm;
}
if (newThing == null)
{
newThing = Randomizer.startTransition;
}
Queue <string> updates = new Queue <string>();
HashSet <string> reachable = new HashSet <string>(reachableTransitions);
reachable.Add(newThing);
pm.AddTemp(newThing);
updates.Enqueue(newThing);
while (updates.Any())
{
string next = updates.Dequeue();
foreach (string transition in LogicManager.GetTransitionsByProgression(recentProgression))
{
if (!reachable.Contains(transition) && pm.CanGet(transition))
{
reachable.Add(transition);
pm.AddTemp(transition);
updates.Enqueue(transition);
if (transitionPlacements.TryGetValue(transition, out string transition2))
{
reachable.Add(transition2);
pm.AddTemp(transition2);
updates.Enqueue(transition2);
}
}
}
if (!updates.Any()) // check vanilla items last, because these almost never change
{
foreach (string loc in LogicManager.GetLocationsByProgression(recentProgression))
{
if (!vanillaProgression.Contains(loc) && !checkProgression.Contains(loc))
{
continue;
}
if (!pm.Has(loc) && pm.CanGet(loc))
{
pm.AddTemp(loc);
updates.Enqueue(loc);
}
}
}
}
reachable.ExceptWith(reachableTransitions);
pm.RemoveTempItems();
return(reachable);
}
public void UpdateReachableLocations(string newThing = null)
{
if (newThing != null)
{
pm.Add(newThing);
updateQueue.Enqueue(newThing);
}
HashSet <string> potentialLocations;
HashSet <string> potentialTransitions = new HashSet <string>();
while (updateQueue.Any())
{
potentialLocations = LogicManager.GetLocationsByProgression(recentProgression);
if (RandomizerMod.Instance.Settings.RandomizeTransitions)
{
potentialTransitions = LogicManager.GetTransitionsByProgression(recentProgression);
}
recentProgression = new HashSet <string>();
string item = updateQueue.Dequeue();
foreach (string location in potentialLocations)
{
if (pm.CanGet(location))
{
reachableLocations.Add(location);
if (vm.progressionLocations.Contains(location))
{
vm.UpdateVanillaLocations(location);
}
}
}
if (RandomizerMod.Instance.Settings.RandomizeTransitions)
{
if (TransitionManager.transitionPlacements.TryGetValue(item, out string transition1) && !pm.Has(transition1))
{
pm.Add(transition1);
updateQueue.Enqueue(transition1);
}
foreach (string transition in potentialTransitions)
{
if (!pm.Has(transition) && pm.CanGet(transition))
{
pm.Add(transition);
updateQueue.Enqueue(transition);
if (TransitionManager.transitionPlacements.TryGetValue(transition, out string transition2) && !pm.Has(transition2))
{
pm.Add(transition2);
updateQueue.Enqueue(transition2);
}
}
}
}
}
}
public void UpdateReachableTransitions(string newThing = null, bool item = false, ProgressionManager _pm = null)
{
if (_pm != null)
{
pm = _pm;
}
if (newThing == null)
{
newThing = Randomizer.startTransition;
}
Queue <string> updates = new Queue <string>();
if (!item)
{
reachableTransitions.Add(newThing);
}
pm.Add(newThing);
updates.Enqueue(newThing);
while (updates.Any())
{
string next = updates.Dequeue();
if (transitionPlacements.TryGetValue(next, out string next2) && !reachableTransitions.Contains(next2))
{
reachableTransitions.Add(next2);
pm.Add(next2);
updates.Enqueue(next2);
}
HashSet <string> potentialTransitions = LogicManager.GetTransitionsByProgression(recentProgression);
recentProgression = new HashSet <string>();
foreach (string transition in potentialTransitions)
{
if (!reachableTransitions.Contains(transition) && pm.CanGet(transition))
{
reachableTransitions.Add(transition);
pm.Add(transition);
updates.Enqueue(transition);
if (transitionPlacements.TryGetValue(transition, out string transition2))
{
reachableTransitions.Add(transition2);
pm.Add(transition2);
updates.Enqueue(transition2);
}
}
}
}
}
public void UpdateReachableTransitions(string newThing = "Tutorial_01[right1]", bool item = false, ProgressionManager _pm = null)
{
if (_pm != null)
{
pm = _pm;
}
Queue <string> updates = new Queue <string>();
if (!item)
{
reachableTransitions.Add(newThing);
}
pm.Add(newThing);
updates.Enqueue(newThing);
while (updates.Any())
{
string next = updates.Dequeue();
if (transitionPlacements.TryGetValue(next, out string next2) && !reachableTransitions.Contains(next2))
{
reachableTransitions.Add(next2);
pm.Add(next2);
updates.Enqueue(next2);
}
foreach (string transition in LogicManager.GetTransitionsByProgression(next))
{
if (!reachableTransitions.Contains(transition) && pm.CanGet(transition))
{
reachableTransitions.Add(transition);
pm.Add(transition);
updates.Enqueue(transition);
if (transitionPlacements.TryGetValue(transition, out string transition2))
{
reachableTransitions.Add(transition2);
pm.Add(transition2);
updates.Enqueue(transition2);
}
}
}
}
}
private HashSet <string> FakeUpdateReachableTransitions(string newThing = null, ProgressionManager _pm = null)
{
if (_pm != null)
{
pm = _pm;
}
if (newThing == null)
{
newThing = Randomizer.startTransition;
}
Queue <string> updates = new Queue <string>();
HashSet <string> reachable = new HashSet <string>(reachableTransitions);
reachable.Add(newThing);
pm.AddTemp(newThing);
updates.Enqueue(newThing);
while (updates.Any())
{
string next = updates.Dequeue();
foreach (string transition in LogicManager.GetTransitionsByProgression(recentProgression))
{
if (!reachable.Contains(transition) && pm.CanGet(transition))
{
reachable.Add(transition);
pm.AddTemp(transition);
updates.Enqueue(transition);
if (transitionPlacements.TryGetValue(transition, out string transition2))
{
reachable.Add(transition2);
pm.AddTemp(transition2);
updates.Enqueue(transition2);
}
}
}
}
reachable.ExceptWith(reachableTransitions);
pm.RemoveTempItems();
return(reachable);
}
private HashSet <string> FakeUpdateReachableTransitions(string newThing = "Tutorial_01[right1]", ProgressionManager _pm = null)
{
if (_pm != null)
{
pm = _pm;
}
Queue <string> updates = new Queue <string>();
HashSet <string> reachable = new HashSet <string>(reachableTransitions);
reachable.Add(newThing);
pm.Add(newThing);
updates.Enqueue(newThing);
while (updates.Any())
{
string next = updates.Dequeue();
foreach (string transition in LogicManager.GetTransitionsByProgression(next))
{
if (!reachable.Contains(transition) && pm.CanGet(transition))
{
reachable.Add(transition);
pm.Add(transition);
updates.Enqueue(transition);
if (transitionPlacements.TryGetValue(transition, out string transition2))
{
reachable.Add(transition2);
pm.Add(transition2);
updates.Enqueue(transition2);
}
}
}
}
reachable.ExceptWith(reachableTransitions);
foreach (string transition in reachable)
{
pm.Remove(transition);
}
return(reachable);
}
public string ForceItem()
{
Queue <string> progressionQueue = new Queue <string>();
List <string> tempProgression = new List <string>();
void UpdateTransitions()
{
foreach (string transition in LogicManager.GetTransitionsByProgression(pm.tempItems))
{
if (!pm.Has(transition) && pm.CanGet(transition))
{
tempProgression.Add(transition);
progressionQueue.Enqueue(transition);
pm.Add(transition);
if (TransitionManager.transitionPlacements.TryGetValue(transition, out string transition2))
{
tempProgression.Add(transition2);
progressionQueue.Enqueue(transition2);
pm.Add(transition2);
}
}
}
}
bool CheckForNewLocations()
{
foreach (string location in LogicManager.GetLocationsByProgression(pm.tempItems))
{
if (randomizedLocations.Contains(location) && !reachableLocations.Contains(location) && pm.CanGet(location))
{
return(true);
}
}
return(false);
}
for (int i = 0; i < unplacedProgression.Count; i++)
{
bool found = false;
string item = unplacedProgression[i];
pm.AddTemp(item);
if (CheckForNewLocations())
{
found = true;
}
else if (RandomizerMod.Instance.Settings.RandomizeTransitions)
{
UpdateTransitions();
while (progressionQueue.Any())
{
progressionQueue.Dequeue();
UpdateTransitions();
found = found || CheckForNewLocations();
}
}
pm.RemoveTempItems();
if (found)
{
return(item);
}
}
return(null);
}
public void UpdateReachableTransitions(string newThing = null, bool item = false, ProgressionManager _pm = null)
{
if (_pm != null)
{
pm = _pm;
}
if (newThing == null)
{
newThing = Randomizer.startTransition;
}
Queue <string> updates = new Queue <string>();
if (!item)
{
reachableTransitions.Add(newThing);
}
pm.Add(newThing);
updates.Enqueue(newThing);
while (updates.Any())
{
string next = updates.Dequeue();
if (transitionPlacements.TryGetValue(next, out string next2) && !reachableTransitions.Contains(next2))
{
reachableTransitions.Add(next2);
pm.Add(next2);
updates.Enqueue(next2);
}
HashSet <string> potentialTransitions = LogicManager.GetTransitionsByProgression(recentProgression);
// update possible vanilla locations
HashSet <string> potentialLocations = LogicManager.GetLocationsByProgression(recentProgression);
potentialLocations.IntersectWith(vanillaProgression);
if (potentialLocations.Any())
{
checkProgression.UnionWith(potentialLocations);
vanillaProgression.ExceptWith(checkProgression);
}
recentProgression = new HashSet <string>();
foreach (string transition in potentialTransitions)
{
if (!reachableTransitions.Contains(transition) && pm.CanGet(transition))
{
reachableTransitions.Add(transition);
pm.Add(transition);
updates.Enqueue(transition);
if (transitionPlacements.TryGetValue(transition, out string transition2))
{
reachableTransitions.Add(transition2);
pm.Add(transition2);
updates.Enqueue(transition2);
}
}
}
if (!updates.Any()) // vanilla locations are very unlikely to enter into logic, so we only check them right before the loop ends
{
List <string> iterate = new List <string>();
foreach (string loc in checkProgression)
{
if (pm.CanGet(loc))
{
pm.Add(loc);
iterate.Add(loc); // **Don't**modify**collection**while**iterating**
updates.Enqueue(loc);
}
}
checkProgression.ExceptWith(iterate);
}
}
}