Example #1
0
        public bool FindRoadEndingOnCurrentStart(PuzzleRoad road)
        {
            var newPuzzleIndex = road.EndPuzzleIndex.HasValue ? road.EndPuzzleIndex.Value : road.StartPuzzleIndex;
            //var tileString = String.Join(" + ", UsedTileList.OrderBy(s => s.PuzzleIndex).Select(s => s.ToString()));
            //var test = UsedTileList;
            //if (tileString == "1 - 1 - 0° + 2 - 2 - 0° + 3 - 3 - 0° + 4 - 7 - 0° + 5 - 4 - 0° + 6 - 5 - 90°")
            //{

            //}
            var switchStartToEnd = false;

            if (road.StartsOrEndsAt(1))
            {
                var findRoad = Enumerable.Empty <PuzzleRoad>();
                if (road.EndPosition == 1)
                {
                    findRoad = OpenPuzzleRoads.Where(s => newPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) + 3 &&
                                                     s.StartsOrEndsAt(6));
                }
                if (!findRoad.Any() && road.StartPosition == 1)
                {
                    findRoad = OpenPuzzleRoads.Where(s => road.StartPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) + 3 &&
                                                     s.StartsOrEndsAt(6));
                    if (findRoad.Count() == 1)
                    {
                        switchStartToEnd = true;
                    }
                }

                if (findRoad.Count() == 1)
                {
                    var relevantRoad = findRoad.First();
                    if (!CheckForRoundabout(road, relevantRoad))
                    {
                        road.CombineRoad(relevantRoad, switchStartToEnd);
                        ChangePuzzleRoadListsBasedOnEndings(road, relevantRoad);
                    }
                    return(true);
                }
            }
            if (road.StartsOrEndsAt(2))
            {
                var findRoad = Enumerable.Empty <PuzzleRoad>();
                if (road.EndPosition == 2)
                {
                    findRoad = OpenPuzzleRoads.Where(s => newPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) + 3 &&
                                                     s.StartsOrEndsAt(5));
                }
                if (!findRoad.Any() && road.StartPosition == 2)
                {
                    findRoad = OpenPuzzleRoads.Where(s => road.StartPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) + 3 &&
                                                     s.StartsOrEndsAt(5));
                    if (findRoad.Count() == 1)
                    {
                        switchStartToEnd = true;
                    }
                }

                if (findRoad.Count() == 1)
                {
                    var relevantRoad = findRoad.First();
                    if (!CheckForRoundabout(road, relevantRoad))
                    {
                        road.CombineRoad(relevantRoad, switchStartToEnd);
                        ChangePuzzleRoadListsBasedOnEndings(road, relevantRoad);
                    }
                    return(true);
                }
            }
            if (road.StartsOrEndsAt(3))
            {
                var findRoad = Enumerable.Empty <PuzzleRoad>();
                if (road.EndPosition == 3 && newPuzzleIndex != 3) // Otherwise puzzle index 3 looks to the right (puzzle index 4) for roads
                {
                    findRoad = OpenPuzzleRoads.Where(s => newPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) - 1 &&
                                                     s.StartsOrEndsAt(8));
                }
                if (!findRoad.Any() && road.StartPosition == 3 && road.StartPuzzleIndex != 3)
                {
                    findRoad = OpenPuzzleRoads.Where(s => road.StartPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) - 1 &&
                                                     s.StartsOrEndsAt(8));
                    if (findRoad.Count() == 1)
                    {
                        switchStartToEnd = true;
                    }
                }

                if (findRoad.Count() == 1)
                {
                    var relevantRoad = findRoad.First();
                    if (!CheckForRoundabout(road, relevantRoad))
                    {
                        road.CombineRoad(relevantRoad, switchStartToEnd);
                        ChangePuzzleRoadListsBasedOnEndings(road, relevantRoad);
                    }
                    return(true);
                }
            }
            if (road.StartsOrEndsAt(4))
            {
                var findRoad = Enumerable.Empty <PuzzleRoad>();
                if (road.EndPosition == 4 && newPuzzleIndex != 3) // Otherwise puzzle index 3 looks to the right (puzzle index 4) for roads
                {
                    findRoad = OpenPuzzleRoads.Where(s => newPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) - 1 &&
                                                     s.StartsOrEndsAt(7));
                }
                if (!findRoad.Any() && road.StartPosition == 4 && road.StartPuzzleIndex != 3)
                {
                    findRoad = OpenPuzzleRoads.Where(s => road.StartPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) - 1 &&
                                                     s.StartsOrEndsAt(7));
                    if (findRoad.Count() == 1)
                    {
                        switchStartToEnd = true;
                    }
                }

                if (findRoad.Count() == 1)
                {
                    var relevantRoad = findRoad.First();
                    if (!CheckForRoundabout(road, relevantRoad))
                    {
                        road.CombineRoad(relevantRoad, switchStartToEnd);
                        ChangePuzzleRoadListsBasedOnEndings(road, relevantRoad);
                    }
                    return(true);
                }
            }
            if (road.StartsOrEndsAt(5))
            {
                var findRoad = Enumerable.Empty <PuzzleRoad>();
                if (road.EndPosition == 5)
                {
                    findRoad = OpenPuzzleRoads.Where(s => newPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) - 3 &&
                                                     s.StartsOrEndsAt(2));
                }
                if (!findRoad.Any() && road.StartPosition == 5)
                {
                    findRoad = OpenPuzzleRoads.Where(s => road.StartPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) - 3 &&
                                                     s.StartsOrEndsAt(2));
                    if (findRoad.Count() == 1)
                    {
                        switchStartToEnd = true;
                    }
                }

                if (findRoad.Count() == 1)
                {
                    var relevantRoad = findRoad.First();
                    if (!CheckForRoundabout(road, relevantRoad))
                    {
                        road.CombineRoad(relevantRoad, switchStartToEnd);
                        ChangePuzzleRoadListsBasedOnEndings(road, relevantRoad);
                    }
                    return(true);
                }
            }
            if (road.StartsOrEndsAt(6))
            {
                var findRoad = Enumerable.Empty <PuzzleRoad>();
                if (road.EndPosition == 6)
                {
                    findRoad = OpenPuzzleRoads.Where(s => newPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) - 3 &&
                                                     s.StartsOrEndsAt(1));
                }
                if (!findRoad.Any() && road.StartPosition == 6)
                {
                    findRoad = OpenPuzzleRoads.Where(s => road.StartPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) - 3 &&
                                                     s.StartsOrEndsAt(1));
                    if (findRoad.Count() == 1)
                    {
                        switchStartToEnd = true;
                    }
                }

                if (findRoad.Count() == 1)
                {
                    var relevantRoad = findRoad.First();
                    if (!CheckForRoundabout(road, relevantRoad))
                    {
                        road.CombineRoad(relevantRoad, switchStartToEnd);
                        ChangePuzzleRoadListsBasedOnEndings(road, relevantRoad);
                    }
                    return(true);
                }
            }
            if (road.StartsOrEndsAt(7))
            {
                var findRoad = Enumerable.Empty <PuzzleRoad>();
                if (road.EndPosition == 7 && newPuzzleIndex != 4) // Otherwise puzzle index 4 looks to the left (puzzle index 3) for roads
                {
                    findRoad = OpenPuzzleRoads.Where(s => newPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) + 1 &&
                                                     s.StartsOrEndsAt(4));
                }
                if (!findRoad.Any() && road.StartPosition == 7 && road.StartPuzzleIndex != 4)
                {
                    findRoad = OpenPuzzleRoads.Where(s => road.StartPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) + 1 &&
                                                     s.StartsOrEndsAt(4));
                    if (findRoad.Count() == 1)
                    {
                        switchStartToEnd = true;
                    }
                }

                if (findRoad.Count() == 1)
                {
                    var relevantRoad = findRoad.First();
                    if (!CheckForRoundabout(road, relevantRoad))
                    {
                        road.CombineRoad(relevantRoad, switchStartToEnd);
                        ChangePuzzleRoadListsBasedOnEndings(road, relevantRoad);
                    }
                    return(true);
                }
            }
            if (road.StartsOrEndsAt(8))
            {
                var findRoad = Enumerable.Empty <PuzzleRoad>();
                if (road.EndPosition == 8 && newPuzzleIndex != 4) // Otherwise puzzle index 4 looks to the left (puzzle index 3) for roads
                {
                    findRoad = OpenPuzzleRoads.Where(s => newPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) + 1 &&
                                                     s.StartsOrEndsAt(3));
                }
                if (!findRoad.Any() && road.StartPosition == 8 && road.StartPuzzleIndex != 4)
                {
                    findRoad = OpenPuzzleRoads.Where(s => road.StartPuzzleIndex == (s.EndPuzzleIndex.HasValue ? s.EndPuzzleIndex.Value : s.StartPuzzleIndex) + 1 &&
                                                     s.StartsOrEndsAt(3));
                    if (findRoad.Count() == 1)
                    {
                        switchStartToEnd = true;
                    }
                }

                if (findRoad.Count() == 1)
                {
                    var relevantRoad = findRoad.First();
                    if (!CheckForRoundabout(road, relevantRoad))
                    {
                        road.CombineRoad(relevantRoad, switchStartToEnd);
                        ChangePuzzleRoadListsBasedOnEndings(road, relevantRoad);
                    }
                    return(true);
                }
            }

            //Het gaat hier HELEMAAL niet goed. Er is geen weg gevonden!?
            return(false);
        }
        public PuzzleRoad FindRoadEndingOnCurrentStart(PuzzleRoad road)
        {
            if (road.StartsOrEndsAt(Orientation.Bottom))
            {
                var findRpad = OpenPuzzleRoads.Where(s => (road.StartPuzzleIndex == s.StartPuzzleIndex - 3 || road.StartPuzzleIndex == s.StartPuzzleIndex + 3) &&
                                                     ((road.EndPosition == s.EndPosition + 2 && s.EndsAt(Orientation.Top)) ||
                                                      (road.EndPosition == s.StartPosition + 2 && s.StartsAt(Orientation.Top)) ||
                                                      (road.StartPosition == s.StartPosition + 2 && s.StartsAt(Orientation.Top)) ||
                                                      (road.StartPosition == s.EndPosition + 2 && s.EndsAt(Orientation.Top))));

                if (!findRpad.Any() || findRpad.Count() > 1)
                {
                    //Dit giet even krek mis. Teveel of te weinig roads!
                    var test = UsedTileList;
                }
                else
                {
                    var relevantRoad = findRpad.First();
                    if (road.PuzzleIndexArray.Count > 1)
                    {
                        road.CombineRoad(relevantRoad);
                        if (IsEndingRoad(ref road, relevantRoad.StartPuzzleIndex))
                        {
                            road.EndPuzzleIndex = relevantRoad.StartPuzzleIndex;
                            OpenPuzzleRoads.Remove(road);
                            DefinitivePuzzleRoads.Add(road);
                        }
                    }
                    else
                    {
                        road.CombineRoad(relevantRoad);
                        if (IsEndingRoad(ref road, null))
                        {
                            road.EndPuzzleIndex = relevantRoad.StartPuzzleIndex;
                            OpenPuzzleRoads.Remove(road);
                            DefinitivePuzzleRoads.Add(road);
                        }
                        OpenPuzzleRoads.Remove(relevantRoad);
                        return(road);
                    }
                }
            }

            if (road.StartsOrEndsAt(Orientation.Top))
            {
                var findRpad = OpenPuzzleRoads.Where(s => (road.StartPuzzleIndex == s.StartPuzzleIndex - 3 || road.StartPuzzleIndex == s.StartPuzzleIndex + 3) &&
                                                     ((road.EndPosition == s.EndPosition - 2 && s.EndsAt(Orientation.Bottom)) ||
                                                      (road.EndPosition == s.StartPosition - 2 && s.StartsAt(Orientation.Bottom)) ||
                                                      (road.StartPosition == s.StartPosition - 2 && s.StartsAt(Orientation.Bottom)) ||
                                                      (road.StartPosition == s.EndPosition - 2 && s.EndsAt(Orientation.Bottom))));

                if (!findRpad.Any() || findRpad.Count() > 1)
                {
                    //Dit giet even krek mis. Teveel of te weinig roads!
                    var test = UsedTileList;
                }
                else
                {
                    var getFirst = findRpad.First();
                    {
                        road.CombineRoad(getFirst);
                        OpenPuzzleRoads.Remove(road);
                        OpenPuzzleRoads.Remove(getFirst);
                        DefinitivePuzzleRoads.Add(road);
                        return(road);
                    }
                }
            }

            //Het gaat hier HELEMAAL niet goed. Er is geen weg gevonden!?
            return(null);
        }