public void RandomizeStaticPokemon(bool legendForLegend)
{
// Load
var currentStaticPokemon = RomHandler.StaticPokemon;
if (legendForLegend)
{
var legendariesLeft = ValidPokemons.ToList();
var nonlegsLeft = ValidPokemons.ToList();
legendariesLeft.RemoveAll(p => !p.Legendary);
nonlegsLeft.RemoveAll(p => p.Legendary);
for (var i = 0; i < currentStaticPokemon.Length; ++i)
{
if (currentStaticPokemon[i].Legendary)
{
var num = Random.Next(legendariesLeft.Count);
currentStaticPokemon[i] = legendariesLeft[num];
legendariesLeft.RemoveAt(num);
if (legendariesLeft.Count != 0)
{
continue;
}
legendariesLeft.AddRange(ValidPokemons.Where(p => p.Legendary));
}
else
{
var num = Random.Next(nonlegsLeft.Count);
currentStaticPokemon[i] = nonlegsLeft[num];
nonlegsLeft.RemoveAt(num);
if (nonlegsLeft.Count != 0)
{
continue;
}
nonlegsLeft.AddRange(ValidPokemons.Where(p => !p.Legendary));
}
}
}
else
{
var pokemonLeft = ValidPokemons.ToList();
for (var i = 0; i < currentStaticPokemon.Length; i++)
{
var num = Random.Next(pokemonLeft.Count);
currentStaticPokemon[i] = pokemonLeft[num];
pokemonLeft.RemoveAt(num);
if (pokemonLeft.Count == 0)
{
pokemonLeft.AddRange(ValidPokemons);
}
}
}
}
private List <Pokemon> PokemonOfType(Typing type, bool noLegendaries)
{
return(ValidPokemons
.Where(
pk => pk != null &&
(!noLegendaries || !pk.Legendary) &&
(pk.PrimaryType == type || pk.SecondaryType == type))
.ToList());
}
public Pokemon Random2EvosPokemon()
{
var twoEvoPokes =
ValidPokemons
.Where(
pk => pk.EvolutionsTo.Count == 0 &&
pk.EvolutionsFrom.Any(ev => ev.To.EvolutionsFrom.Count > 0))
.ToArray();
return(twoEvoPokes[Random.Next(twoEvoPokes.Length)]);
}
public void Area1To1Encounters(
bool useTimeOfDay,
bool catchEmAll,
bool typeThemed,
bool usePowerLevels,
bool noLegendaries)
{
var pickFrom = noLegendaries ? ValidPokemons.Where(p => !p.Legendary) : ValidPokemons;
var enumerable = pickFrom as Pokemon[] ?? pickFrom.ToArray();
// New: randomize the order encounter sets are randomized in.
// Leads to less predictable results for various modifiers.
// Need to keep the original ordering around for saving though.
var scrambledEncounters = new List <EncounterSet>(RomHandler.Encounters);
scrambledEncounters.Shuffle(Random);
// Assume EITHER catch em all OR type themed for now
if (catchEmAll)
{
var allPokes = enumerable.ToList();
foreach (var area in scrambledEncounters)
{
// Poke-set
var inArea = PokemonInArea(area);
// Build area map using catch em all
var areaMap = new Dictionary <Pokemon, Pokemon>();
var pickablePokemon = allPokes;
if (area.BannedPokemon.Count > 0)
{
pickablePokemon = new List <Pokemon>(allPokes);
pickablePokemon.RemoveAll(area.BannedPokemon.Contains);
}
foreach (var areaPk in inArea)
{
if (pickablePokemon.Count == 0)
{
// No more pickable pokes left, take a random one
var tempPickable = enumerable.ToList();
tempPickable.RemoveAll(area.BannedPokemon.Contains);
if (tempPickable.Count == 0)
{
throw new NotImplementedException("ERROR: Couldn\'t replace a wild Pokemon!");
}
var picked = Random.Next(tempPickable.Count);
var pickedMn = tempPickable[picked];
areaMap[areaPk] = pickedMn;
}
else
{
var picked = Random.Next(allPokes.Count);
var pickedMn = allPokes[picked];
areaMap[areaPk] = pickedMn;
pickablePokemon.Remove(pickedMn);
if (allPokes != pickablePokemon)
{
allPokes.Remove(pickedMn);
}
if (allPokes.Count != 0)
{
continue;
}
allPokes.AddRange(enumerable);
if (pickablePokemon == allPokes)
{
continue;
}
pickablePokemon.AddRange(allPokes);
pickablePokemon.RemoveAll(area.BannedPokemon.Contains);
}
}
// Apply the map
foreach (var enc in area.Encounters)
{
enc.Pokemon1 = areaMap[enc.Pokemon1];
}
}
}
else if (typeThemed)
{
var cachedPokeLists = new Dictionary <Typing, List <Pokemon> >();
foreach (var area in scrambledEncounters)
{
// Poke-set
var inArea = PokemonInArea(area);
List <Pokemon> possiblePokemon = null;
var iterLoops = 0;
while (possiblePokemon == null &&
iterLoops < 10000)
{
var areaTheme = RandomType();
if (!cachedPokeLists.ContainsKey(areaTheme))
{
var pType = PokemonOfType(areaTheme, noLegendaries);
cachedPokeLists[areaTheme] = pType;
}
possiblePokemon = new List <Pokemon>(cachedPokeLists[areaTheme]);
if (area.BannedPokemon.Count > 0)
{
possiblePokemon.RemoveAll(area.BannedPokemon.Contains);
}
if (possiblePokemon.Count < inArea.Count)
{
possiblePokemon = null;
}
iterLoops++;
}
if (possiblePokemon == null)
{
throw new NotImplementedException(
"Could not randomize an area in a reasonable amount of attempts.");
}
// Build area map using type theme.
var areaMap = new Dictionary <Pokemon, Pokemon>();
foreach (var areaPk in inArea)
{
var picked = Random.Next(possiblePokemon.Count);
var pickedMn = possiblePokemon[picked];
areaMap[areaPk] = pickedMn;
possiblePokemon.RemoveAt(picked);
}
foreach (var enc in area.Encounters)
{
// Apply the map
enc.Pokemon1 = areaMap[enc.Pokemon1];
}
}
}
else if (usePowerLevels)
{
var allowedPokes = enumerable.ToList();
foreach (var area in scrambledEncounters)
{
// Poke-set
var inArea = PokemonInArea(area);
// Build area map using randoms
var areaMap = new Dictionary <Pokemon, Pokemon>();
var usedPks = new List <Pokemon>();
var localAllowed = allowedPokes;
if (area.BannedPokemon.Count > 0)
{
localAllowed = new List <Pokemon>(allowedPokes);
localAllowed.RemoveAll(area.BannedPokemon.Contains);
}
foreach (var areaPk in inArea)
{
var picked = PickWildPowerLvlReplacement(localAllowed, areaPk, false, usedPks);
areaMap[areaPk] = picked;
usedPks.Add(picked);
}
// Apply the map
foreach (var enc in area.Encounters)
{
enc.Pokemon1 = areaMap[enc.Pokemon1];
}
}
}
else
{
// Entirely random
foreach (var area in scrambledEncounters)
{
// Poke-set
var inArea = PokemonInArea(area);
// Build area map using randoms
var areaMap = new Dictionary <Pokemon, Pokemon>();
foreach (var areaPk in inArea)
{
var picked = noLegendaries ? RandomPokemon(p => !p.Legendary) : RandomPokemon();
while (areaMap.ContainsValue(picked) || area.BannedPokemon.Contains(picked))
{
picked = noLegendaries ? RandomPokemon(p => !p.Legendary) : RandomPokemon();
}
areaMap[areaPk] = picked;
}
foreach (var enc in area.Encounters)
{
// Apply the map
enc.Pokemon1 = areaMap[enc.Pokemon1];
}
}
}
}
public void RandomEncounters(EncountersRandomization encountersRandomization, bool noLegendaries)
{
var pickFrom = noLegendaries ? ValidPokemons.Where(p => !p.Legendary) : ValidPokemons;
var enumerable = pickFrom as Pokemon[] ?? pickFrom.ToArray();
var currentEncounters = RomHandler.Encounters.ToList();
currentEncounters.Shuffle(Random);
switch (encountersRandomization)
{
case EncountersRandomization.CatchEmAll:
// Clone, so we don't modify original
var allPokes = enumerable.ToList();
foreach (var area in currentEncounters)
{
var pickablePokemon = allPokes;
if (area.BannedPokemon.Count > 0)
{
// Clone, so we don't modify original
pickablePokemon = allPokes.ToList();
pickablePokemon.RemoveAll(area.BannedPokemon);
}
foreach (var enc in area.Encounters)
{
if (pickablePokemon.Count == 0)
{
// Clone, so we don't modify original
var tempPickable = enumerable.ToList();
tempPickable.RemoveAll(area.BannedPokemon);
if (tempPickable.Count == 0)
{
throw new NotImplementedException("ERROR: Couldn't replace a wild Pokemon!");
}
enc.Pokemon1 = tempPickable[Random.Next(tempPickable.Count)];
}
else
{
var picked = Random.Next(pickablePokemon.Count);
enc.Pokemon1 = pickablePokemon[picked];
pickablePokemon.RemoveAt(picked);
if (allPokes != pickablePokemon)
{
allPokes.Remove(enc.Pokemon1);
}
if (allPokes.Count != 0)
{
continue;
}
allPokes.AddRange(enumerable);
if (pickablePokemon == allPokes)
{
continue;
}
pickablePokemon.AddRange(allPokes);
pickablePokemon.RemoveAll(area.BannedPokemon);
}
}
}
break;
case EncountersRandomization.TypeThemed:
var cachedPokeLists = new SortedDictionary <Typing, IList <Pokemon> >();
foreach (var area in currentEncounters)
{
IList <Pokemon> possiblePokemon = null;
var iterLoops = 0;
while (possiblePokemon == null && iterLoops < 10000)
{
var areaTheme = RandomType();
if (!cachedPokeLists.ContainsKey(areaTheme))
{
IList <Pokemon> pType = PokemonOfType(areaTheme, noLegendaries);
cachedPokeLists[areaTheme] = pType;
}
possiblePokemon = cachedPokeLists[areaTheme];
if (area.BannedPokemon.Count > 0)
{
possiblePokemon = possiblePokemon.ToList();
possiblePokemon.RemoveAll(area.BannedPokemon);
}
if (possiblePokemon.Count == 0)
{
possiblePokemon = null;
}
iterLoops++;
}
if (possiblePokemon == null)
{
throw new NotImplementedException(
"Could not randomize an area in a reasonable amount of attempts.");
}
foreach (var enc in area.Encounters)
{
enc.Pokemon1 = possiblePokemon[Random.Next(possiblePokemon.Count)];
}
}
break;
case EncountersRandomization.UsePowerLevel:
var allowedPokes = enumerable.ToList();
foreach (var area in currentEncounters)
{
var localAllowed = allowedPokes;
if (area.BannedPokemon.Count > 0)
{
localAllowed = allowedPokes.ToList();
localAllowed.RemoveAll(area.BannedPokemon);
}
foreach (var enc in area.Encounters)
{
enc.Pokemon1 = PickWildPowerLvlReplacement(localAllowed, enc.Pokemon1, false, null);
}
}
break;
default:
foreach (var area in currentEncounters)
{
foreach (var enc in area.Encounters)
{
enc.Pokemon1 = noLegendaries ? RandomPokemon(p => !p.Legendary) : RandomPokemon();
while (area.BannedPokemon.Contains(enc.Pokemon1))
{
enc.Pokemon1 = noLegendaries ? RandomPokemon(p => !p.Legendary) : RandomPokemon();
}
}
}
break;
}
}
public void Game1To1Encounters(bool useTimeOfDay, bool usePowerLevels, bool noLegendaries)
{
var pickFrom = noLegendaries ? ValidPokemons.Where(p => !p.Legendary) : ValidPokemons;
var enumerable = pickFrom as Pokemon[] ?? pickFrom.ToArray();
// Build the full 1-to-1 map
var translateMap = new Dictionary <Pokemon, Pokemon>();
var remainingLeft = ValidPokemons.ToList();
var remainingRight = enumerable.ToList();
while (remainingLeft.Count != 0)
{
if (usePowerLevels)
{
var pickedLeft = Random.Next(remainingLeft.Count);
var pickedLeftP = remainingLeft[pickedLeft];
remainingLeft.RemoveAt(pickedLeft);
var pickedRightP = remainingRight.Count == 1
? remainingRight[0]
: PickWildPowerLvlReplacement(remainingRight, pickedLeftP, true, null);
remainingRight.Remove(pickedRightP);
translateMap[pickedLeftP] = pickedRightP;
}
else
{
var pickedLeft = Random.Next(remainingLeft.Count);
var pickedRight = Random.Next(remainingRight.Count);
var pickedLeftP = remainingLeft[pickedLeft];
var pickedRightP = remainingRight[pickedRight];
remainingLeft.RemoveAt(pickedLeft);
while (pickedLeftP.Id == pickedRightP.Id &&
remainingRight.Count != 1)
{
// Reroll for a different pokemon if at all possible
pickedRight = Random.Next(remainingRight.Count);
pickedRightP = remainingRight[pickedRight];
}
remainingRight.RemoveAt(pickedRight);
translateMap[pickedLeftP] = pickedRightP;
}
if (remainingRight.Count != 0)
{
continue;
}
remainingRight.AddRange(enumerable);
}
// Map remaining to themselves just in case
var allPokes = ValidPokemons;
foreach (var poke in allPokes)
{
if (!translateMap.ContainsKey(poke))
{
translateMap[poke] = poke;
}
}
foreach (var area in RomHandler.Encounters)
{
foreach (var enc in area.Encounters)
{
// Apply the map
enc.Pokemon1 = translateMap[enc.Pokemon1];
if (!area.BannedPokemon.Contains(enc.Pokemon1))
{
continue;
}
// Ignore the map and put a random non-banned poke
var tempPickable = enumerable.ToList();
tempPickable.RemoveAll(area.BannedPokemon.Contains);
if (tempPickable.Count == 0)
{
throw new NotImplementedException("ERROR: Couldn\'t replace a wild Pokemon!");
}
if (usePowerLevels)
{
enc.Pokemon1 = PickWildPowerLvlReplacement(tempPickable, enc.Pokemon1, false, null);
}
else
{
var picked = Random.Next(tempPickable.Count);
enc.Pokemon1 = tempPickable[picked];
}
}
}
}
