Пример #1
0
        public bool DoEarlyBailOut()
        {
            var bailOut = false;

            FillPuzzleRoads(UsedTileList);

            if (DefinitivePuzzleRoads.Count > 0)
            {
                bailOut = EarlyBailOut();
            }

            if (bailOut)
            {
                var bailOutString = String.Format("Bailing out at: {0}", String.Join(" AND ", UsedTileList.Select(s => s.ToString())));
                Debug.WriteLine(bailOutString);
                //Upvote all tiles in current and deeper layers with corresponding amounts?
                var allKeys = UsedTileList/*.Where(s => s.PuzzleDepthCounter >= UsedTileList.Count)*/
                              .Select(s => new UsedTileDictionaryKey(s.PuzzleIndex, s.TileNumber, s.Degrees)).ToList();

                var x = "bla";
                CheckTileCountAndUpIfNeeded(true);
                return(true);

                //There is still a problem when the first bailOut is the second tile, we add += original layer.
                //The next time the 2nd tile is checked again, the amount is upped by += layer, and it will check again
                foreach (var key in allKeys.OrderByDescending(s => s.PuzzleIndex))
                {
                    var relevantTile = UsedTileList.FirstOrDefault(s =>
                                                                   s.TileNumber == key.TileNumber && s.Degrees == key.Degrees);
                    var relevantLayer = PuzzleIndexCounter[key.PuzzleIndex];

                    if (Initiator.CheckedTileDictionary[key] >= OriginalDepthCounter[relevantLayer])
                    {
                        return(false);
                    }

                    if (relevantTile.PuzzleDepthCounter >= allKeys.Count)
                    {
                        Initiator.CheckedTileDictionary[key] += OriginalDepthCounter[relevantLayer];
                        if (DynamicCheckedTileDictionary[key] < AmountOfMaximumTriesPerTile)
                        {
                            DynamicCheckedTileDictionary[key] += OriginalDepthCounter[relevantLayer];
                        }

                        //var aboveLayer = OriginalDepthCounter.FirstOrDefault(s => s.Key > relevantTile.PuzzleDepthCounter);
                        var usedTileNumbersAboveThisLayer = allKeys.Where(s => s.PuzzleIndex <= DepthToIndex[relevantLayer]).Select(a => a.TileNumber).ToList();
                        var relevantIndex          = DepthToIndex[relevantLayer];
                        var everyKeyExceptUsedOnes = DynamicCheckedTileDictionary.Where(s =>
                                                                                        s.Key.PuzzleIndex > relevantIndex &&
                                                                                        !usedTileNumbersAboveThisLayer.Contains(s.Key.TileNumber)).ToList();

                        foreach (var keyEx in everyKeyExceptUsedOnes)
                        {
                            //Update the count for the next round
                            var layer = PuzzleIndexCounter[keyEx.Key.PuzzleIndex];
                            Initiator.CheckedTileDictionary[keyEx.Key] += OriginalDepthCounter[layer];
                            DynamicCheckedTileDictionary[keyEx.Key]    += OriginalDepthCounter[layer];
                        }

                        RemoveAndResetPuzzleTile(relevantTile);
                        //UsedTileList.Remove(relevantTile);
                        //UsedPuzzleTilesIndices.Remove(key.PuzzleIndex);
                        //relevantTile.PuzzleDepthCounter = 0;
                        //relevantTile.PuzzleIndex = -1;
                        //UsedTileDictionary[key.TileNumber] = false;
                    }
                    else
                    {
                        //var layer = PuzzleIndexCounter[key.PuzzleIndex];
                        Initiator.CheckedTileDictionary[key] += OriginalDepthCounter[relevantLayer + 1];

                        if (Initiator.CheckedTileDictionary[key] >= DynamicCheckedTileDictionary[key])
                        {
                            //var relevantTile = UsedTileList.FirstOrDefault(s =>
                            //s.TileNumber == notKey.TileNumber && s.Degrees == notKey.Degrees);
                            RemoveAndResetPuzzleTile(relevantTile);
                            //UsedTileList.Remove(relevantTile);
                            //UsedPuzzleTilesIndices.Remove(key.PuzzleIndex);
                            //relevantTile.PuzzleDepthCounter = 0;
                            //relevantTile.PuzzleIndex = -1;
                            //UsedTileDictionary[key.TileNumber] = false;
                        }
                    }
                }

                //We bailed out, clear list and break
                //var allNotKeys = UsedTileList.Where(s => s.PuzzleDepthCounter <= UsedTileList.Count)
                //.Select(s => new UsedTileDictionaryKey(s.PuzzleIndex, s.TileNumber, s.Degrees)).ToList();
                //foreach (var notKey in allNotKeys)
                //{

                //}

                return(true);
            }

            return(false);
        }
Пример #2
0
        private void CheckTileCountAndUpIfNeeded(bool didBailOut)
        {
            var usedTileNumbers = UsedTileList.Select(s => s.TileNumber);
            var allKeys         = UsedTileList.Select(s => new UsedTileDictionaryKey(s.PuzzleIndex, s.TileNumber, s.Degrees)).ToList();
            //var otherTileKeys = Initiator.TotalRotationTileList.Where(s => !usedTileNumbers.Contains(s.TileNumber));
            var uppedAboveTiles = false;

            if (AmountOfCheckedSolutions % 480 == 0)
            {
            }

            if (!didBailOut)
            {
            }

            var dynamicNotMaxedOut = DynamicCheckedTileDictionary.Where(s => s.Value < AmountOfMaximumTriesPerTile).ToList();

            //var dynamicLowerThanChecked = DynamicCheckedTileDictionary.Where(a => a.Value <= CheckedTileDictionary[a.Key] && a.Value != AmountOfMaximumTriesPerTile).ToList();
            //if (dynamicLowerThanChecked.Any())
            //{

            //}

            if (didBailOut)
            {
                //if (!uppedAboveTiles)
                {
                    var lastTile         = UsedTileList.OrderBy(s => s.PuzzleIndex).LastOrDefault();
                    var keysAboveCurrent = allKeys.Where(s => PuzzleIndexCounter[s.PuzzleIndex] <= lastTile.PuzzleDepthCounter).ToList();
                    var relevantLayer    = PuzzleIndexCounter[lastTile.PuzzleIndex];
                    var oriDepthAmount   = OriginalDepthCounter[relevantLayer];
                    if (keysAboveCurrent.Any())
                    {
                        foreach (var keyAbove in keysAboveCurrent)
                        {
                            if (CheckedTileDictionary[keyAbove] + oriDepthAmount <= AmountOfMaximumTriesPerTile)
                            {
                                CheckedTileDictionary[keyAbove] += oriDepthAmount;
                            }
                        }
                        uppedAboveTiles = true;
                    }


                    //var usedTileKeysBelowThisLayer = CheckedTileDictionary.Keys.Where(s => s.PuzzleIndex > key.PuzzleIndex && !usedTileNumbers.Contains(s.TileNumber));
                    var usedTileKeysBelowThisLayer = DynamicCheckedTileDictionary.Keys.Where(s =>
                                                                                             s.PuzzleIndex > lastTile.PuzzleIndex &&
                                                                                             !usedTileNumbers.Contains(s.TileNumber)).ToList();
                    var firstLayerAfterBailOut = relevantLayer + 1;
                    foreach (var otKey in usedTileKeysBelowThisLayer)
                    {
                        var otKeyLayer = PuzzleIndexCounter[otKey.PuzzleIndex];
                        if (DynamicCheckedTileDictionary[otKey] + OriginalDepthCounter[firstLayerAfterBailOut] <= AmountOfMaximumTriesPerTile)
                        {
                            if (otKey.PuzzleIndex == 5 && otKey.TileNumber == 2 && otKey.Degrees == 0 && DynamicCheckedTileDictionary[otKey] >= 440)
                            {
                            }
                            DynamicCheckedTileDictionary[otKey] += OriginalDepthCounter[firstLayerAfterBailOut];
                        }
                        else
                        {
                            Debug.WriteLine(String.Format("We bailout out, but did NOT up the below layer! {0}", otKey.ToString()));
                            //Lets fill it up towards max
                            DynamicCheckedTileDictionary[otKey] = AmountOfMaximumTriesPerTile;
                        }
                        CheckedTileDictionary[otKey] += OriginalDepthCounter[firstLayerAfterBailOut];
                    }

                    var keysAboveCurrentlayer        = allKeys.Where(s => PuzzleIndexCounter[s.PuzzleIndex] != lastTile.PuzzleDepthCounter);
                    var tileNumbersAboveCurrentLayer = keysAboveCurrentlayer.Select(s => s.TileNumber);
                    var tilesInSameLayer             = CheckedTileDictionary.Keys.Where(s => s.PuzzleIndex == lastTile.PuzzleIndex && !tileNumbersAboveCurrentLayer.Contains(s.TileNumber));
                    var key           = new UsedTileDictionaryKey(lastTile.PuzzleIndex, lastTile.TileNumber, lastTile.Degrees);
                    var allSameAmount = tilesInSameLayer.All(a => CheckedTileDictionary[a] == CheckedTileDictionary[key] && CheckedTileDictionary[a] != AmountOfMaximumTriesPerTile);

                    if (allSameAmount)
                    {
                        foreach (var tsl in tilesInSameLayer)
                        {
                            if (DynamicCheckedTileDictionary[tsl] + oriDepthAmount <= AmountOfMaximumTriesPerTile)
                            {
                                DynamicCheckedTileDictionary[tsl] += oriDepthAmount;
                            }
                        }
                    }

                    foreach (var kkey in keysAboveCurrent)
                    {
                        var rTile = UsedTileList.FirstOrDefault(s => s.PuzzleIndex == kkey.PuzzleIndex && s.TileNumber == kkey.TileNumber && s.Degrees == kkey.Degrees);
                        //See if one of the used keys (starting at the end) has been used too much
                        if (Initiator.CheckedTileDictionary[kkey] >= DynamicCheckedTileDictionary[kkey])
                        {
                            RemoveAndResetPuzzleTile(rTile);
                            //break;
                        }
                    }
                    //RemoveAndResetPuzzleTile(lastTile);
                }

                var dynamicLowerThanChecked = DynamicCheckedTileDictionary.Where(a => a.Value <= CheckedTileDictionary[a.Key] && a.Value != AmountOfMaximumTriesPerTile).ToList();
                if (dynamicLowerThanChecked.Any())
                {
                }

                return;
            }

            foreach (var key in allKeys.OrderByDescending(s => s.PuzzleIndex))
            {
                var relevantTile = UsedTileList.FirstOrDefault(s =>
                                                               s.TileNumber == key.TileNumber && s.Degrees == key.Degrees);
                var relevantLayer   = PuzzleIndexCounter[key.PuzzleIndex];
                var oriDepthAmount  = OriginalDepthCounter[relevantLayer];
                var dynamicKeyCount = DynamicCheckedTileDictionary[key];

                //else
                {
                    //Only up if there is an actual checked solution
                    if (allKeys.Count == SubmittedPuzzleTileCount)
                    {
                        if (CheckedTileDictionary[key] + 1 <= dynamicKeyCount)
                        {
                            CheckedTileDictionary[key]++;
                        }

                        //if (CheckedTileDictionary[key] > 0)
                        //{
                        //    var keysAboveCurrentlayer = allKeys.Where(s => PuzzleIndexCounter[s.PuzzleIndex] != relevantTile.PuzzleDepthCounter);
                        //    var tileNumbersAboveCurrentLayer = keysAboveCurrentlayer.Select(s => s.TileNumber);
                        //    var tilesInSameLayer = CheckedTileDictionary.Keys.Where(s => s.PuzzleIndex == key.PuzzleIndex && !tileNumbersAboveCurrentLayer.Contains(s.TileNumber));
                        //    var allSameAmount = tilesInSameLayer.All(a => CheckedTileDictionary[a] == CheckedTileDictionary[key]);

                        //    if (allSameAmount)
                        //    {
                        //        if (DynamicCheckedTileDictionary[key] + oriDepthAmount <= AmountOfMaximumTriesPerTile)
                        //        {
                        //            foreach (var otKey in tilesInSameLayer)
                        //            {
                        //                DynamicCheckedTileDictionary[new UsedTileDictionaryKey(key.PuzzleIndex, otKey.TileNumber, otKey.Degrees)] += oriDepthAmount;
                        //            }
                        //        }
                        //    }
                        //}

                        //foreach (var akey in allKeys.OrderByDescending(s => s.PuzzleIndex))
                        //{
                        //var relevantTile = UsedTileList.FirstOrDefault(s =>
                        //s.TileNumber == akey.TileNumber && s.Degrees == akey.Degrees);

                        //See if one of the used keys (starting at the end) has been used too much
                        if (Initiator.CheckedTileDictionary[key] >= DynamicCheckedTileDictionary[key])
                        {
                            //UsedPuzzleTilesIndices.Remove(key.PuzzleIndex);
                            //UsedTileList.Remove(relevantTile);
                            //UsedTileDictionary[key.TileNumber] = false;

                            //var keysAboveCurrentlayer = allKeys.Where(s => PuzzleIndexCounter[s.PuzzleIndex] != relevantTile.PuzzleDepthCounter);
                            //var tileNumbersAboveCurrentLayer = keysAboveCurrentlayer.Select(s => s.TileNumber);
                            //var tilesInSameLayer = CheckedTileDictionary.Keys.Where(s => s.PuzzleIndex == key.PuzzleIndex && !tileNumbersAboveCurrentLayer.Contains(s.TileNumber));

                            //We should only += the DynamicDepthCounter in the above layers.
                            var aboveLayer = OriginalDepthCounter.FirstOrDefault(s => s.Key > relevantTile.PuzzleDepthCounter);
                            if (aboveLayer.Key != 0)
                            {
                                var usedTileNumbersAboveThisLayer = allKeys.Where(s => s.PuzzleIndex < DepthToIndex[aboveLayer.Key]).Select(a => a.TileNumber).ToList();
                                var relevantIndex          = DepthToIndex[aboveLayer.Key];
                                var everyKeyExceptUsedOnes = DynamicCheckedTileDictionary.Where(s =>
                                                                                                s.Key.PuzzleIndex == relevantIndex &&
                                                                                                !usedTileNumbersAboveThisLayer.Contains(s.Key.TileNumber)).ToList();

                                foreach (var keyEx in everyKeyExceptUsedOnes)
                                {
                                    //Update the count for the next round
                                    DynamicCheckedTileDictionary[keyEx.Key] += OriginalDepthCounter[aboveLayer.Key];
                                }
                            }

                            RemoveAndResetPuzzleTile(relevantTile);

                            //relevantTile.PuzzleDepthCounter = 0;
                            //relevantTile.PuzzleIndex = -1;
                        }
                        //}
                    }
                }

                var dynamicLowerThanChecked = DynamicCheckedTileDictionary.Where(a => a.Value <= CheckedTileDictionary[a.Key] && a.Value != AmountOfMaximumTriesPerTile).ToList();
                if (dynamicLowerThanChecked.Any())
                {
                }

                //See if one of the used keys (starting at the end) has been used too much
                if (Initiator.CheckedTileDictionary[key] >= dynamicKeyCount && didBailOut)
                {
                    RemoveAndResetPuzzleTile(relevantTile);
                    break;
                }
            }
        }