/// <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; } }