/// <summary>
/// Builds the file To Generate Game Data
/// </summary>
/// <param name="divisions">All Division information</param>
/// <param name="prizeLevels">All Prize Level information</param>
/// <param name="gameInfo">All game Inforamtion</param>
/// <param name="fileName">The full output file name and pat</param>
public void buildGameData(
Divisions.DivisionsModel divisions,
PrizeLevels.PrizeLevels prizeLevels,
GameSetup.GameSetupModel gameInfo,
string fileName)
{
int numberOfDivisions = divisions.getNumberOfDivisions() + 1;
List<int[]>[] divisionLevels = new List<int[]>[numberOfDivisions];
List<Thread> threads = new List<Thread>();
for (int i = 0; i < numberOfDivisions; i++)
{
int divisionIndex = i;
Thread t;
if (divisionIndex == numberOfDivisions - 1)
{
t = new Thread(() => divisionLevels[divisionIndex] = getDivisionLossingPermutations(gameInfo, prizeLevels, divisions).OrderBy(a => Guid.NewGuid()).ToList());
}
else
{
int temp = i;
t = new Thread(() => divisionLevels[divisionIndex] = getDivisionWinningPermutations(divisionIndex, gameInfo.totalPicks, divisions.getDivision(temp).MaxPermutations, divisions.getDivision(divisionIndex), prizeLevels).OrderBy(a => Guid.NewGuid()).ToList());
}
t.Start();
threads.Add(t);
}
for (int i = 0; i < threads.Count; i++)
{
threads.ElementAt(i).Join();
}
writeFile(fileName, divisionLevels, new List<string>());
}
public void testBuildGameDataThreeDivisonsFourPicksWithLoss()
{
//Custom input for a game
GameSetupModel gs = new GameSetupModel();
gs.maxPermutations = 1000;
gs.totalPicks = 4;
PrizeLevel pl1 = new PrizeLevel();
pl1.isInstantWin = false;
pl1.numCollections = 3;
pl1.prizeValue = 100;
PrizeLevel pl2 = new PrizeLevel();
pl2.isInstantWin = false;
pl2.numCollections = 2;
pl2.prizeValue = 50;
PrizeLevel pl3 = new PrizeLevel();
pl3.isInstantWin = false;
pl3.numCollections = 2;
pl3.prizeValue = 25;
PrizeLevels pls = new PrizeLevels();
pls.addPrizeLevel(pl1);
pls.addPrizeLevel(pl2);
pls.addPrizeLevel(pl3);
DivisionModel dm1 = new DivisionModel();
dm1.addPrizeLevel(pl1);
DivisionModel dm2 = new DivisionModel();
dm2.addPrizeLevel(pl2);
DivisionModel dm3 = new DivisionModel();
dm3.addPrizeLevel(pl2);
dm3.addPrizeLevel(pl3);
DivisionModel dm4 = new DivisionModel();
DivisionsModel dms = new DivisionsModel();
dms.addDivision(dm1);
dms.addDivision(dm2);
dms.addDivision(dm3);
dms.addDivision(dm4);
//File Generator
FileGenerationService fgs = new FileGenerationService();
fgs.buildGameData(dms, pls, gs, "testBuildGameDataThreeDivisonsFourPicksWithLoss");
}
public void Test_Invalid_Remove_Prize_Level()
{
PrizeLevels pls = new PrizeLevels();
pls.removePrizeLevel(5);
Assert.IsTrue(pls.getNumPrizeLevels() == 0);
}
public void Test_Invalid_Add_Prize_Level()
{
PrizeLevels pls = new PrizeLevels();
pls.addPrizeLevel(null);
Assert.IsTrue(pls.getNumPrizeLevels() == 0);
}
private void DataBindLocale()
{
DataContext = _localization;
PrizeLevels.SetLocalization(_localization.PrizeLevelsPanel);
GameSetup.SetLocalization(_localization.GameSetupPanel);
Divisions.SetLocalization(_localization.DivisionPanel);
SetErrorText();
}
public void Test_Invalid_Level_Prize_Level()
{
PrizeLevels pls = new PrizeLevels();
PrizeLevel pl1 = new PrizeLevel();
pls.addPrizeLevel(pl1);
Assert.IsTrue(pls.getLevelOfPrize(null) == -1);
}
public void Test_Invalid_Add_At_Prize_Level()
{
PrizeLevels pls = new PrizeLevels();
PrizeLevel pl1 = new PrizeLevel();
pls.addPrizeLevelAt(null, 0);
pls.addPrizeLevelAt(pl1, 40);
Assert.IsTrue(pls.getNumPrizeLevels() == 0);
}
public void Test_Add_Get_Prize_Level()
{
PrizeLevels pls = new PrizeLevels();
PrizeLevel pl1 = new PrizeLevel();
pls.addPrizeLevel(pl1);
Assert.IsTrue(pl1.Equals(pls.getPrizeLevel(0)));
}
private void DataBindLocale()
{
DataContext = _localization;
Language.DataContext = _localization;
Language.DataContext = this;
PrizeLevels.SetLocalization(_localization.PrizeLevelsPanel);
GameSetup.SetLocalization(_localization.GameSetupPanel);
Divisions.SetLocalization(_localization.DivisionPanel);
ErrorService.Instance.SetLocalization(_localization.ErrorService);
}
/// <summary>
/// Board generation creates the board for play. The board uses a doubly linked list for its design.
/// </summary>
/// <param name="boardSize">Board size is the total size of the board</param>
/// <param name="initialReachable">The number of spaces that are reachable without accounting for special tiles</param>
/// <param name="minMove">The min movement a player can make in a turn</param>
/// <param name="maxMove">The max movement a player can make in a turn</param>
/// <param name="moveBackCount">The number of move back spaces</param>
/// <param name="moveForwardCount">The number of move forward spaces</param>
/// <param name="prizes">All the game prizes</param>
/// <param name="moveForward">How far move forward tiles will move you</param>
/// <param name="moveBack">How far move back tiles will move you</param>
/// <returns>Returns the first tile of the board.</returns>
public ITile GenerateBoard(int boardSize,
int initialReachable,
int minMove,
int maxMove,
int moveBackCount,
int moveForwardCount,
PrizeLevels.PrizeLevels prizes,
int moveForward = 1,
int moveBack = 1)
{
int numberOfCollectionSpots = 0;
foreach (PrizeLevels.PrizeLevel p in prizes.prizeLevels)
{
if ( _threadCancel != null && _threadCancel.Cancel ) return null;
numberOfCollectionSpots += p.numCollections;
}
FillInBlankBoardTiles(boardSize);
if ( _threadCancel != null && _threadCancel.Cancel ) return null;
TileTypes[] specialTiles = new TileTypes[moveBackCount + moveForwardCount];
TileTypes[] collectionTiles = new TileTypes[numberOfCollectionSpots];
for ( int i = 0; i < collectionTiles.Length && !( _threadCancel != null && _threadCancel.Cancel ); ++i )
{
collectionTiles[i] = TileTypes.collection;
}
if ( _threadCancel != null && _threadCancel.Cancel ) return null;
int index = 0;
while ( index < specialTiles.Length && !( _threadCancel != null && _threadCancel.Cancel ) )
{
if (index < moveForwardCount)
{
specialTiles[index] = TileTypes.moveForward;
}
else
{
specialTiles[index] = TileTypes.moveBack;
}
++index;
}
if ( _threadCancel != null && _threadCancel.Cancel ) return null;
specialTiles = ArrayShuffler<TileTypes>.Shuffle(specialTiles);
if ( _threadCancel != null && _threadCancel.Cancel ) return null;
FillInSpecialTiles(initialReachable, minMove, maxMove, moveForward, moveBack, specialTiles);
if ( _threadCancel != null && _threadCancel.Cancel ) return null;
FillInSpecialTiles(initialReachable, minMove, maxMove, moveForward, moveBack, collectionTiles);
if ( _threadCancel != null && _threadCancel.Cancel ) return null;
FillInCollectionTileValues(minMove, numberOfCollectionSpots, prizes);
if ( _threadCancel != null && _threadCancel.Cancel ) return null;
ConnectTiles(boardSize, minMove, maxMove, moveBack, moveForward);
return _firstTile;
}
public void Test_Add_At_Prize_Level()
{
PrizeLevels pls = new PrizeLevels();
PrizeLevel pl1 = new PrizeLevel();
PrizeLevel pl2 = new PrizeLevel();
pls.addPrizeLevel(pl1);
pls.addPrizeLevelAt(pl2, 0);
Assert.IsTrue(pls.getLevelOfPrize(pl2) == 0);
}
public void Test_Remove_Count_Prize_Level()
{
PrizeLevels pls = new PrizeLevels();
PrizeLevel pl1 = new PrizeLevel();
pls.addPrizeLevel(pl1);
pls.removePrizeLevel(0);
Assert.IsTrue(pls.getNumPrizeLevels() == 0);
}
private void DataBind()
{
PrizeLevels.SetModel(_model.PrizeLevelsModel);
PrizeLevels.SetValidator(VerifyAllModel);
GameSetup.SetModel(_model.GameSetupModel);
Divisions.SetModel(_model.DivisionsModel);
if (_model != null)
{
_model.PrizeLevelsModel.PropertyChanged -= PrizeLevelListChanged;
_model.PrizeLevelsModel.PropertyChanged += PrizeLevelListChanged;
_model.DivisionsModel.SetValidator(VerifyAllModel);
_model.PrizeLevelsModel.SetValidator(VerifyAllModel);
_model.GameSetupModel.SetValidator(VerifyAllModel);
}
PrizeLevelListChanged(this, new PropertyChangedEventArgs("PrizeLevelList2"));
ErrorTextBlock.DataContext = ErrorService.Instance;
WarningTextBlock.DataContext = ErrorService.Instance;
}
public void SaveProject(GameSetupModel gsObject, PrizeLevels.PrizeLevels plsObject, DivisionsModel divisionsList)
{
if (isProjectSaved)
{
savedGameSetup = gsObject;
savedPrizeLevels = plsObject;
savedDivisions = divisionsList;
IFormatter formatter = new BinaryFormatter();
Stream stream = new FileStream(projectFileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
formatter.Serialize(stream, this);
stream.Close();
}
else
{
SaveProjectAs(gsObject, plsObject, divisionsList);
}
}
public void testBuildGameDataMaxDivison()
{
GameSetupModel gs = new GameSetupModel();
gs.maxPermutations = 300000;
gs.totalPicks = 20;
int numPrizeLevels = 12;
PrizeLevel[] prizes = new PrizeLevel[numPrizeLevels];
PrizeLevels pls = new PrizeLevels();
for (int i = 0; i < numPrizeLevels; i++)
{
prizes[i] = new PrizeLevel();
prizes[i].isInstantWin = false;
prizes[i].numCollections = i + 1;
prizes[i].prizeValue = 100 * i;
pls.addPrizeLevel(prizes[i]);
}
int numberOfDivions = 30;
DivisionModel[] divisions = new DivisionModel[numberOfDivions];
DivisionsModel dms = new DivisionsModel();
Random rand = new Random();
for (int i = 0; i < numberOfDivions; i++)
{
divisions[i] = new DivisionModel();
divisions[i].addPrizeLevel(prizes[rand.Next(0, 12)]);
dms.addDivision(divisions[i]);
}
FileGenerationService fgs = new FileGenerationService();
fgs.buildGameData(dms, pls, gs, "T:\\Work\\JunkOut\\MaxTest.txt");
}
public void SaveProjectAs(GameSetupModel gsObject, PrizeLevels.PrizeLevels plsObject, DivisionsModel divisionsList)
{
Microsoft.Win32.SaveFileDialog dialog = new Microsoft.Win32.SaveFileDialog();
if (String.IsNullOrEmpty(projectFileName))
{
dialog.FileName = "CollectionGameGeneratorProject" + DEFAULT_EXT;
}
else
{
dialog.FileName = projectFileName;
}
dialog.DefaultExt = DEFAULT_EXT;
dialog.Filter = FILTER;
bool? result = dialog.ShowDialog();
if (result == true)
{
projectFileName = dialog.FileName;
isProjectSaved = true;
SaveProject(gsObject, plsObject, divisionsList);
}
}
/// <summary>
/// Builds the header information for the file
/// </summary>
/// <param name="prizes">All prize informaiton</param>
/// <param name="divisions">All division information</param>
/// <returns>Returns a list of string representing each line of the header</returns>
private List<string> buildHeader(PrizeLevels.PrizeLevels prizes, Divisions.DivisionsModel divisions)
{
List<string> headerLines = new List<string>();
headerLines.Add("The first number is the division indicator.");
headerLines.Add("Prize level indicators and values:");
int prizeLevel = 1;
StringBuilder sb;
foreach (PrizeLevels.PrizeLevel p in prizes.prizeLevels)
{
sb = new StringBuilder();
sb.Append("Prize Level Character: " + charFromInt(prizes.getLevelOfPrize(p) + 1));
sb.Append(" Value: " + p.prizeValue);
headerLines.Add(sb.ToString());
}
headerLines.Add("Division level indicators and values:");
foreach (Divisions.DivisionModel div in divisions.divisions)
{
sb = new StringBuilder();
sb.Append("Division Number: " + prizeLevel++);
sb.Append(" Value: " + div.TotalPrizeValue);
sb.Append(" Prize Levels at Division: ");
foreach (PrizeLevels.PrizeLevel p in div.getPrizeLevelsAtDivision())
{
sb.Append(charFromInt(prizes.getLevelOfPrize(p) + 1));
}
headerLines.Add(sb.ToString());
}
sb = new StringBuilder();
sb.Append("Division Level Number: " + prizeLevel++);
sb.Append(" Value: " + 0);
headerLines.Add(sb.ToString());
return headerLines;
}
/// <summary>
/// Gets the needed picks to win all prize levels of a given division
/// </summary>
/// <param name="division">The division is the division containing the winning prize levels</param>
/// <param name="prizeLevels">All prize levels in the game used to get the index of the prize level</param>
/// <returns>Returns a list of ints containing the needed picks to win a division</returns>
private List<int> getNeededPicksForDivision(
bool useInstantWin,
Divisions.DivisionModel division,
PrizeLevels.PrizeLevels prizeLevels)
{
List<int> neededPicks = new List<int>();
List<PrizeLevels.PrizeLevel> pls = division.getPrizeLevelsAtDivision();
foreach (PrizeLevels.PrizeLevel pl in pls)
{
int numberToCollect = pl.numCollections;
int indexInPrizeLevels = prizeLevels.getLevelOfPrize(pl) + 1;
if ((pl.isInstantWin || pl.numCollections == 0) && useInstantWin)
{
numberToCollect = 1;
neededPicks.Add(-indexInPrizeLevels);
}
else
{
numberToCollect = pl.numCollections;
for (int i = 0; i < numberToCollect; i++)
{
neededPicks.Add(indexInPrizeLevels);
}
}
}
return neededPicks;
}
/// <summary>
/// Gets complete combinations of near wins
/// </summary>
/// <param name="nearWinPrizeLevels">Number of near wins</param>
/// <param name="totalNumberOfPicks">total number of picks for a level</param>
/// <param name="prizeLevels">All prize levels</param>
/// <returns></returns>
private List<int[]> getPrizeLevelCombinationsForNearWins(
int nearWinPrizeLevels,
int totalNumberOfPicks,
PrizeLevels.PrizeLevels prizeLevels)
{
int numberOfPrizeLevels = prizeLevels.getNumPrizeLevels();
List<int[]> prizeLevelCombinations = new List<int[]>();
int numberOfMaximumCombinations = prizeLevels.getNumPrizeLevels();
List<int> prizeLevelsIndexes = new List<int>();
for (int i = 0; i < numberOfPrizeLevels; i++)
{
prizeLevelsIndexes.Add(i);
}
// Max possible Base
for (int i = 1; i <= nearWinPrizeLevels; i++)
{
for (int j = 0; j < numberOfMaximumCombinations; j++)
{
Random rand = new Random();
int[] tempPrizeLevelCombinations = new int[i];
int numberOfPicksForPrizeLevelCombintation = 0;
bool newBaseComboAdded = false;
int failCount = 0;
List<int> tempPrizeLevelIndexes = new List<int>(prizeLevelsIndexes);
do
{
for (int k = 0; k < i; k++)
{
int randomPrizeLevelSelection = rand.Next(0, tempPrizeLevelIndexes.Count);
numberOfPicksForPrizeLevelCombintation += prizeLevels.getPrizeLevel(tempPrizeLevelIndexes[randomPrizeLevelSelection]).numCollections - 1;
tempPrizeLevelCombinations[k] = tempPrizeLevelIndexes[randomPrizeLevelSelection];
tempPrizeLevelIndexes.RemoveAt(randomPrizeLevelSelection);
}
if (!prizeLevelCombinations.Any(tempPrizeLevelCombinations.SequenceEqual) && numberOfPicksForPrizeLevelCombintation <= totalNumberOfPicks)
{
prizeLevelCombinations.Add(tempPrizeLevelCombinations);
newBaseComboAdded = true;
}
tempPrizeLevelCombinations = new int[i];
numberOfPicksForPrizeLevelCombintation = 0;
tempPrizeLevelIndexes = new List<int>(prizeLevelsIndexes);
failCount++;
} while (!newBaseComboAdded && failCount <= 2500);
}
}
return prizeLevelCombinations;
}
/// <summary>
/// Gets all non winning picks for a given permutation
/// </summary>
/// <param name="permutation"> The base permutation</param>
/// <param name="prizeLevels"> Used to find collection amount for unused pic<s/param>
/// <returns> Returns an array of non winning picks</returns>
private int[] getExtraPicks(
int[] permutation,
PrizeLevels.PrizeLevels prizeLevels)
{
List<int> usedIndexes = new List<int>();
List<int> extraPicks = new List<int>();
foreach (int i in permutation)
{
int j = Math.Abs(i);
if (j - 1 != -1 && !usedIndexes.Contains((j - 1)))
{
usedIndexes.Add(j - 1);
}
}
int numberOfPrizeLevels = prizeLevels.getNumPrizeLevels();
for (int i = 0; i < numberOfPrizeLevels; i++)
{
if (!usedIndexes.Contains(i))
{
int numberOfCollections = prizeLevels.getPrizeLevel(i).numCollections - 1;
for (int j = 0; j < numberOfCollections; j++)
{
extraPicks.Add(i + 1);
}
}
}
return extraPicks.ToArray();
}
/// <summary>
/// Creates all the winning permutations of a divisions
/// </summary>
/// <param name="divisionIndicator">Selected Division</param>
/// <param name="totalNumberOfPicks">Number of picks for a division</param>
/// <param name="numberOfPermutations">number of permutations to genreate for a division</param>
/// <param name="division">Division informaiton</param>
/// <param name="prizeLevels">Prize level informaiton</param>
/// <returns>Returns the list of winning permutaitons for a division</returns>
private List<int[]> getDivisionWinningPermutations(
int divisionIndicator,
short totalNumberOfPicks,
int numberOfPermutations,
Divisions.DivisionModel division,
PrizeLevels.PrizeLevels prizeLevels)
{
List<int[]> divisionIncompleteWinPermutations = new List<int[]>();
List<PrizeLevels.PrizeLevel> divisionPrizeLevels = division.getPrizeLevelsAtDivision();
int maxNumberOfNeededPicksForDivision = 0;
bool isInstantWinPresent = false;
foreach (PrizeLevels.PrizeLevel p in divisionPrizeLevels)
{
maxNumberOfNeededPicksForDivision += p.numCollections;
if (p.isInstantWin)
{
isInstantWinPresent = true;
}
}
int[] picks = getNeededPicksForDivision(true, division, prizeLevels).ToArray();
divisionIncompleteWinPermutations.AddRange(getAllBasePermutations(totalNumberOfPicks, numberOfPermutations, getBaseCombinaiton(totalNumberOfPicks, picks).ToArray()));
int[] nonWinningPicks = getExtraPicks(divisionIncompleteWinPermutations[0], prizeLevels);
if (nonWinningPicks.Length + picks.Length < totalNumberOfPicks && isInstantWinPresent)
{
divisionIncompleteWinPermutations.Clear();
}
if (maxNumberOfNeededPicksForDivision <= totalNumberOfPicks && isInstantWinPresent)
{
divisionIncompleteWinPermutations.AddRange(getAllBasePermutations(totalNumberOfPicks, numberOfPermutations, getBaseCombinaiton(totalNumberOfPicks, getNeededPicksForDivision(false, division, prizeLevels).ToArray()).ToArray()));
}
List<int[]> maximumPermutations = fillBlankDivisionPermutationsWithNonWinningData(
divisionIncompleteWinPermutations,
nonWinningPicks,
division,
prizeLevels,
(numberOfPermutations + extraPermutationBuffer)).OrderBy(a => Guid.NewGuid()).ToList();
List<int[]> finalPermutations = maximumPermutations.Take(numberOfPermutations).ToList();
return finalPermutations;
}
/// <summary>
/// Generates losing permutations for a game
/// </summary>
/// <param name="gameInfo">All game Information</param>
/// <param name="prizeLevels">All prizeLevels</param>
/// <returns>List of int arrays representing losing permutations</returns>
private List<int[]> getDivisionLossingPermutations(
GameSetup.GameSetupModel gameInfo,
PrizeLevels.PrizeLevels prizeLevels,
Divisions.DivisionsModel divisions
)
{
List<int[]> lossPermutations = new List<int[]>();
List<int> extraPicks = getExtraPicks(new int[1], prizeLevels).ToList();
List<int[]> baseLossconditions = new List<int[]>();
int numberOfPermutationsForNearWinAmount = divisions.LossMaxPermutations;
if (gameInfo.isNearWin)
{
baseLossconditions.AddRange(getBaseNearWinLossPermutations(gameInfo.nearWins, gameInfo.totalPicks, prizeLevels));
}
else
{
int[] baseLoss = new int[gameInfo.totalPicks];
baseLossconditions.Add(baseLoss);
}
lossPermutations = getAllLossPermutations(baseLossconditions, prizeLevels, gameInfo.nearWins, numberOfPermutationsForNearWinAmount);
List<int[]> Losses = lossPermutations.Take(divisions.LossMaxPermutations).ToList();
return Losses;
}
public void Test_Invalid_Get_Prize_Level()
{
PrizeLevels pls = new PrizeLevels();
Assert.IsNull(pls.getPrizeLevel(1));
}
public void testBuildGameDataFiveDivisionsNinePicksWithFailDivision()
{
GameSetupModel gs = new GameSetupModel();
gs.maxPermutations = 1000;
gs.totalPicks = 9;
PrizeLevel pl1 = new PrizeLevel();
pl1.isInstantWin = false;
pl1.numCollections = 5;
pl1.prizeValue = 100;
PrizeLevel pl2 = new PrizeLevel();
pl2.isInstantWin = false;
pl2.numCollections = 4;
pl2.prizeValue = 50;
PrizeLevel pl3 = new PrizeLevel();
pl3.isInstantWin = false;
pl3.numCollections = 4;
pl3.prizeValue = 25;
PrizeLevel pl4 = new PrizeLevel();
pl4.isInstantWin = false;
pl4.numCollections = 3;
pl4.prizeValue = 10;
PrizeLevel pl5 = new PrizeLevel();
pl5.isInstantWin = false;
pl5.numCollections = 3;
pl5.prizeValue = 5;
PrizeLevels pls = new PrizeLevels();
pls.addPrizeLevel(pl1);
pls.addPrizeLevel(pl2);
pls.addPrizeLevel(pl3);
pls.addPrizeLevel(pl4);
pls.addPrizeLevel(pl5);
DivisionModel dm1 = new DivisionModel();
dm1.addPrizeLevel(pl1);
DivisionModel dm2 = new DivisionModel();
dm2.addPrizeLevel(pl1);
dm2.addPrizeLevel(pl2);
DivisionModel dm3 = new DivisionModel();
dm3.addPrizeLevel(pl1);
dm3.addPrizeLevel(pl3);
DivisionModel dm4 = new DivisionModel();
dm4.addPrizeLevel(pl2);
dm4.addPrizeLevel(pl3);
DivisionModel dm5 = new DivisionModel();
dm5.addPrizeLevel(pl4);
dm5.addPrizeLevel(pl5);
DivisionModel dm6 = new DivisionModel();
DivisionsModel dms = new DivisionsModel();
dms.addDivision(dm1);
dms.addDivision(dm2);
dms.addDivision(dm3);
dms.addDivision(dm4);
dms.addDivision(dm5);
dms.addDivision(dm6);
FileGenerationService fgs = new FileGenerationService();
fgs.buildGameData(dms, pls, gs, "testBuildGameDataFiveDivisionsNinePicksWithFail");
}
public void testBuildGameDataFourDivisonsFivePicks()
{
//Custom input for a game
GameSetupModel gs = new GameSetupModel();
gs.maxPermutations = 1000;
gs.totalPicks = 5;
gs.isNearWin = true;
gs.nearWins = 2;
PrizeLevel pl1 = new PrizeLevel();
pl1.isInstantWin = false;
pl1.numCollections = 3;
pl1.prizeValue = 100;
PrizeLevel pl2 = new PrizeLevel();
pl2.isInstantWin = false;
pl2.numCollections = 2;
pl2.prizeValue = 50;
PrizeLevel pl3 = new PrizeLevel();
pl3.isInstantWin = false;
pl3.numCollections = 2;
pl3.prizeValue = 25;
PrizeLevel pl4 = new PrizeLevel();
pl4.isInstantWin = false;
pl4.numCollections = 4;
pl4.prizeValue = 10000;
PrizeLevel pl5 = new PrizeLevel();
pl5.isInstantWin = false;
pl5.numCollections = 3;
pl5.prizeValue = 1000;
PrizeLevels pls = new PrizeLevels();
pls.addPrizeLevel(pl1);
pls.addPrizeLevel(pl2);
pls.addPrizeLevel(pl3);
pls.addPrizeLevel(pl4);
pls.addPrizeLevel(pl5);
DivisionModel dm1 = new DivisionModel();
dm1.addPrizeLevel(pl1);
DivisionModel dm2 = new DivisionModel();
dm2.addPrizeLevel(pl2);
DivisionModel dm3 = new DivisionModel();
dm3.addPrizeLevel(pl2);
dm3.addPrizeLevel(pl3);
DivisionModel dm4 = new DivisionModel();
dm4.addPrizeLevel(pl5);
DivisionModel dm5 = new DivisionModel();
dm5.addPrizeLevel(pl5);
dm5.addPrizeLevel(pl2);
DivisionsModel dms = new DivisionsModel();
dms.addDivision(dm1);
dms.addDivision(dm2);
dms.addDivision(dm3);
dms.addDivision(dm4);
dms.addDivision(dm5);
//File Generator
FileGenerationService fgs = new FileGenerationService();
fgs.buildGameData(dms, pls, gs, "T:\\Work\\JunkOut\\testBuildGameDataFourDivisonsFivePicks.txt");
}
/// <summary>
/// Creates extra permutations for each permutation given
/// </summary>
/// <param name="permutations"> A list of base permutations to genreate new permutations from</param>
/// <param name="desiredAmountOfPermutations"> The amount of desired permutations</param>
/// <param name="prizeLevels"> All the prize levels for a given game</param>
/// <returns>Returns a list of all extra permutations from the base list.</returns>
private List<int[]> createExtraPermutations(
List<int[]> permutations,
int desiredAmountOfPermutations,
PrizeLevels.PrizeLevels prizeLevels)
{
HashSet<string> permutationList = new HashSet<string>();
int[] extraPicks = getExtraPicks(permutations[0], prizeLevels);
for (int i = 0; i < permutations.Count && i < desiredAmountOfPermutations + 500 && permutationList.Count <= desiredAmountOfPermutations; i++)
{
HashSet<string> extrasForPerm = createExtraPermutationsFromBase(permutations[i], extraPicks, (int)desiredAmountOfPermutations);
permutationList.UnionWith(extrasForPerm);
}
List<int[]> extraPermutations = new List<int[]>();
foreach (string s in permutationList)
{
extraPermutations.Add(permutationStringToIntArray(s));
}
return extraPermutations;
}
public void testBuildGameDataFourDivisionsSixPicks()
{
GameSetupModel gs = new GameSetupModel();
gs.maxPermutations = 1000;
gs.totalPicks = 6;
PrizeLevel pl1 = new PrizeLevel();
pl1.isInstantWin = false;
pl1.numCollections = 3;
pl1.prizeValue = 100;
PrizeLevel pl2 = new PrizeLevel();
pl2.isInstantWin = false;
pl2.numCollections = 3;
pl2.prizeValue = 50;
PrizeLevel pl3 = new PrizeLevel();
pl3.isInstantWin = false;
pl3.numCollections = 3;
pl3.prizeValue = 25;
PrizeLevels pls = new PrizeLevels();
pls.addPrizeLevel(pl1);
pls.addPrizeLevel(pl2);
pls.addPrizeLevel(pl3);
DivisionModel dm1 = new DivisionModel();
dm1.addPrizeLevel(pl1);
dm1.addPrizeLevel(pl2);
DivisionModel dm2 = new DivisionModel();
dm2.addPrizeLevel(pl2);
dm2.addPrizeLevel(pl3);
DivisionModel dm3 = new DivisionModel();
dm3.addPrizeLevel(pl1);
dm3.addPrizeLevel(pl3);
DivisionModel dm4 = new DivisionModel();
dm4.addPrizeLevel(pl2);
DivisionsModel dms = new DivisionsModel();
dms.addDivision(dm1);
dms.addDivision(dm2);
dms.addDivision(dm3);
dms.addDivision(dm4);
FileGenerationService fgs = new FileGenerationService();
fgs.buildGameData(dms, pls, gs, "testBuildGameDataFourDivisionsSixPicks");
}
/// <summary>
/// Fill the extra spots of a permutation with non winning picks.
/// </summary>
/// <param name="nonWinningPermutations">The non winning permutations</param>
/// <param name="extraPicks">The extra picks to fill in for a division</param>
/// <param name="div">The division</param>
/// <param name="prizeLevels">All prize levels</param>
/// <param name="maxNumberOfpermutations">Max number of permutations to reach.</param>
/// <returns>Returns filled permutations.</returns>
private List<int[]> fillBlankDivisionPermutationsWithNonWinningData(
List<int[]> nonWinningPermutations,
int[] extraPicks,
Divisions.DivisionModel div,
PrizeLevels.PrizeLevels prizeLevels,
int maxNumberOfPermutations)
{
List<int[]> filledPermutations = new List<int[]>();
filledPermutations = createExtraPermutations(nonWinningPermutations, maxNumberOfPermutations, prizeLevels);
return filledPermutations;
}
/// <summary>
/// Gets all permutations for a losing condition. Can be different if near win is needed.
/// </summary>
/// <param name="baseLossconditions">The base set of lossing permutations</param>
/// <param name="prizeLevels">All of the prize level information</param>
/// <param name="numberOfNearWins">How many near wins can there be</param>
/// <param name="maxNumberOfpermutationsPerNearWin">Maximum number of permutations </param>
/// <returns> Returns a list of all losing permutations</returns>
private List<int[]> getAllLossPermutations(
List<int[]> baseLossconditions,
PrizeLevels.PrizeLevels prizeLevels,
int numberOfNearWins,
int maxNumberOfPermutationsPerNearWin)
{
List<int[]> lossPermutations = new List<int[]>();
int[] nearWinCounts = new int[numberOfNearWins + 1];
foreach (int[] lossCondition in baseLossconditions)
{
int nearWinType = 0;
for (int i = 1; i < lossCondition.Length; i++)
{
if (lossCondition[i] != lossCondition[i - 1])
{
nearWinType++;
}
}
int[] basePermutation = new int[lossCondition.Length];
lossCondition.CopyTo(basePermutation, 0);
bool ableToFindNextdivision = true;
for (int i = nearWinCounts[nearWinType]; i < maxNumberOfPermutationsPerNearWin && ableToFindNextdivision; i++)
{
int[] newPermutation = new int[lossCondition.Length];
lossCondition.CopyTo(newPermutation, 0);
if (ableToFindNextdivision)
{
lossPermutations.Add(newPermutation);
nearWinCounts[nearWinType]++;
}
basePermutation = findNextPermutation(lossCondition);
ableToFindNextdivision = !(basePermutation[0] == -1);
}
}
return createExtraPermutations(lossPermutations, maxNumberOfPermutationsPerNearWin + extraPermutationBuffer, prizeLevels); ;
}
/// <summary>
/// Creates the base combinations for near win losing conditions.
/// </summary>
/// <param name="nearWinPrizeLevels">Number of max near wins</param>
/// <param name="totalNumberOfPicks">Total number of picks for a divisions</param>
/// <param name="prizeLevels">All the prize levels</param>
/// <returns>Returns a list of base combinations</returns>
private List<int[]> getBaseNearWinLossPermutations(
int nearWinPrizeLevels,
int totalNumberOfPicks,
PrizeLevels.PrizeLevels prizeLevels)
{
List<int[]> nearWinBasePermutations = new List<int[]>();
List<int[]> prizeLevelCombinations = getPrizeLevelCombinationsForNearWins(nearWinPrizeLevels, totalNumberOfPicks, prizeLevels);
foreach (int[] combo in prizeLevelCombinations)
{
List<int> neededPicks = new List<int>();
for (int i = 0; i < combo.Length; i++)
{
int prizeLevelToSelect = combo[i];
for (int k = 0; k < prizeLevels.getPrizeLevel(prizeLevelToSelect).numCollections - 1; k++)
{
neededPicks.Add(combo[i] + 1);
}
}
nearWinBasePermutations.Add(getBaseCombinaiton(totalNumberOfPicks, neededPicks.ToArray()).ToArray());
}
return nearWinBasePermutations;
}
/// <summary>
/// Constructor for Division paylevel
/// </summary>
/// <param name="parent"></param>
public DivisionModel(DivisionsModel parent = null)
{
_parent = parent;
LastPrizeLevelIndex = -1;
PrizeLevel = PrizeLevels.First();
}
/// <summary>
/// Fills in the collection spaces prize level values
/// </summary>
/// <param name="minMove">The min move</param>
/// <param name="numberOfCollectionSpots">The number of collection spots</param>
/// <param name="prizes">The prizes</param>
private void FillInCollectionTileValues(
int minMove,
int numberOfCollectionSpots,
PrizeLevels.PrizeLevels prizes)
{
int index = 0;
string[] prizeLevel = new string[numberOfCollectionSpots];
foreach (PrizeLevels.PrizeLevel p in prizes.prizeLevels)
{
if ( _threadCancel != null && _threadCancel.Cancel ) return;
for ( int i = 0; i < p.numCollections && !( _threadCancel != null && _threadCancel.Cancel ); ++i )
{
StringBuilder sb = new StringBuilder();
//sb.Append("CS");
if (p.isInstantWin)
sb.Append(":I");
if (p.isBonusGame)
sb.Append(":B");
sb.Append((":" + (char)(p.prizeLevel + 97)));
prizeLevel[index] = sb.ToString();
++index;
}
}
if ( _threadCancel != null && _threadCancel.Cancel ) return;
int collectionValuesFilled = 0;
Tiles.ITile current = _firstTile;
prizeLevel = ArrayShuffler<string>.Shuffle(prizeLevel);
if ( _threadCancel != null && _threadCancel.Cancel ) return;
while ( collectionValuesFilled != numberOfCollectionSpots && !( _threadCancel != null && _threadCancel.Cancel ) )
{
if (current == null)
{
prizeLevel = ArrayShuffler<string>.Shuffle(prizeLevel);
if ( _threadCancel != null && _threadCancel.Cancel ) return;
current = _firstTile;
collectionValuesFilled = 0;
}
if (current.Type == Tiles.TileTypes.collection)
{
Tiles.ITile backtracker = current;
for ( int j = 1; j < minMove && !( _threadCancel != null && _threadCancel.Cancel ); ++j )
{
if (backtracker.Parent != null)
backtracker = backtracker.Parent;
}
if ( _threadCancel != null && _threadCancel.Cancel ) return;
if (backtracker == current || backtracker.Type != Tiles.TileTypes.collection || (backtracker.Type == Tiles.TileTypes.collection && backtracker.TileInformation != prizeLevel[collectionValuesFilled]))
{
current.TileInformation = prizeLevel[collectionValuesFilled++];
}
}
current = current.Child;
}
}
