public void RationalizeRiverContoursInCorner_DoesNothingIfLeftAndRightRiversOnSameRiver_AndAdjacentInThatRiver()
        {
            var center = BuildCell();
            var left   = BuildCell();
            var right  = BuildCell();

            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.NE)).Returns(left);
            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.E)).Returns(right);

            MockRiverCanon.Setup(canon => canon.HasRiverAlongEdge(center, HexDirection.NE)).Returns(true);
            MockRiverCanon.Setup(canon => canon.HasRiverAlongEdge(center, HexDirection.E)).Returns(true);
            MockRiverCanon.Setup(canon => canon.HasRiverAlongEdge(left, HexDirection.SE)).Returns(true);

            var centerLeftSection  = new RiverSection();
            var centerRightSection = new RiverSection();

            MockRiverSectionCanon.Setup(canon => canon.GetSectionBetweenCells(center, left)).Returns(centerLeftSection);
            MockRiverSectionCanon.Setup(canon => canon.GetSectionBetweenCells(center, right)).Returns(centerRightSection);

            BuildRiver(new RiverSection(), centerLeftSection, centerRightSection, new RiverSection());

            var riverRationalizer = Container.Resolve <RiverContourRationalizer>();

            riverRationalizer.RationalizeRiverContoursInCorner(center, HexDirection.E);

            MockContourRationalizer.Verify(
                rationalizer => rationalizer.RationalizeCellContours(
                    It.IsAny <IHexCell>(), It.IsAny <HexDirection>()
                    ), Times.Never, "RationalizerCellContours unexpectedly called"
                );
        }
Beispiel #2
0
        public void GetNextActiveSectionForRiver_AndValidCenterLeftSectionExists_ReturnsCenterLeftSection()
        {
            var center    = BuildCell();
            var left      = BuildCell();
            var right     = BuildCell();
            var nextRight = BuildCell();

            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.NE)).Returns(left);
            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.SE)).Returns(nextRight);

            var activeSection = new RiverSection()
            {
                AdjacentCellOne = center, AdjacentCellTwo = right, DirectionFromOne = HexDirection.E
            };
            var lastSection = new RiverSection();

            var centerLeftSection = new RiverSection();

            var unassignedSections = new HashSet <RiverSection>()
            {
                centerLeftSection
            };

            MockSectionCanon.Setup(canon => canon.GetSectionBetweenCells(center, left)).Returns(centerLeftSection);
            MockSectionCanon.Setup(canon => canon.IsNeighborOf(centerLeftSection, lastSection)).Returns(false);
            MockSectionCanon.Setup(canon => canon.AreSectionFlowsCongruous(activeSection, centerLeftSection)).Returns(true);

            var utilities = Container.Resolve <RiverBuilderUtilities>();

            Assert.AreEqual(centerLeftSection, utilities.GetNextActiveSectionForRiver(activeSection, lastSection, unassignedSections));
        }
        public void RationalizeRiverContoursInCorner_RationalizesCellContours_IfLeftAndRightOnDifferentRivers()
        {
            var center = BuildCell();
            var left   = BuildCell();
            var right  = BuildCell();

            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.NE)).Returns(left);
            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.E)).Returns(right);

            MockRiverCanon.Setup(canon => canon.HasRiverAlongEdge(center, HexDirection.NE)).Returns(true);
            MockRiverCanon.Setup(canon => canon.HasRiverAlongEdge(center, HexDirection.E)).Returns(true);
            MockRiverCanon.Setup(canon => canon.HasRiverAlongEdge(left, HexDirection.SE)).Returns(true);

            var centerLeftSection  = new RiverSection();
            var centerRightSection = new RiverSection();

            MockRiverSectionCanon.Setup(canon => canon.GetSectionBetweenCells(center, left)).Returns(centerLeftSection);
            MockRiverSectionCanon.Setup(canon => canon.GetSectionBetweenCells(center, right)).Returns(centerRightSection);

            var riverRationalizer = Container.Resolve <RiverContourRationalizer>();

            riverRationalizer.RationalizeRiverContoursInCorner(center, HexDirection.E);

            MockContourRationalizer.Verify(
                rationalizer => rationalizer.RationalizeCellContours(
                    It.IsAny <IHexCell>(), It.IsAny <HexDirection>()
                    ), Times.Once, "RationalizerCellContours called an unexpected number of times"
                );

            MockContourRationalizer.Verify(
                rationalizer => rationalizer.RationalizeCellContours(center, HexDirection.E),
                Times.Once, "RationalizerCellContours wasn't called as expected"
                );
        }
Beispiel #4
0
        public void SetCurveStatusOfSection_AndRiverContainsCenterNextRightSection_NextOnInternalCurveSetToTrue()
        {
            var center    = BuildCell();
            var nextRight = BuildCell();

            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.SE)).Returns(nextRight);

            var centerNextRightSection = new RiverSection();

            MockSectionCanon.Setup(canon => canon.GetSectionBetweenCells(center, nextRight)).Returns(centerNextRightSection);

            var sectionToTest = new RiverSection()
            {
                AdjacentCellOne = center, DirectionFromOne = HexDirection.E
            };

            var river = new List <RiverSection>()
            {
                centerNextRightSection, new RiverSection()
            };

            var utilities = Container.Resolve <RiverBuilderUtilities>();

            utilities.SetCurveStatusOfSection(sectionToTest, river);

            Assert.IsTrue(sectionToTest.NextOnInternalCurve);
        }
Beispiel #5
0
        public void BuildRiverFromSection_StartingSectionHasNextEndpoint_AndCWFlow_ReversesRiver()
        {
            var startingSection = new RiverSection()
            {
                HasNextEndpoint = true, FlowFromOne = RiverFlow.Clockwise
            };

            var sectionOne   = new RiverSection();
            var sectionTwo   = new RiverSection();
            var sectionThree = new RiverSection();

            var unassignedRiverSections = new HashSet <RiverSection>();

            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(startingSection, null, unassignedRiverSections)).Returns(sectionOne);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionOne, startingSection, unassignedRiverSections)).Returns(sectionTwo);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionTwo, sectionOne, unassignedRiverSections)).Returns(sectionThree);

            var riverBuilder = Container.Resolve <RiverBuilder>();

            CollectionAssert.AreEqual(
                new List <RiverSection>()
            {
                sectionThree, sectionTwo, sectionOne, startingSection
            },
                riverBuilder.BuildRiverFromSection(startingSection, unassignedRiverSections)
                );
        }
Beispiel #6
0
        public void SetCurveStatusOfSection_AndRiverDoesntContainCenterLeftSection_PreviousOnInternalCurveSetToFalse()
        {
            var center = BuildCell();
            var left   = BuildCell();

            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.NE)).Returns(left);

            MockSectionCanon.Setup(canon => canon.GetSectionBetweenCells(center, left)).Returns(new RiverSection());

            var sectionToTest = new RiverSection()
            {
                AdjacentCellOne = center, DirectionFromOne = HexDirection.E
            };

            var river = new List <RiverSection>()
            {
                new RiverSection(), new RiverSection()
            };

            var utilities = Container.Resolve <RiverBuilderUtilities>();

            utilities.SetCurveStatusOfSection(sectionToTest, river);

            Assert.IsFalse(sectionToTest.PreviousOnInternalCurve);
        }
Beispiel #7
0
        public void BuildRiverFromSection_PullsAndAddsActiveSections_UntilANextEndpointIsFound()
        {
            var startingSection = new RiverSection();

            var unassignedRiverSections = new HashSet <RiverSection>();

            var sectionOne   = new RiverSection();
            var sectionTwo   = new RiverSection();
            var sectionThree = new RiverSection()
            {
                HasNextEndpoint = true
            };
            var sectionFour = new RiverSection()
            {
                HasNextEndpoint = true
            };

            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(startingSection, null, unassignedRiverSections)).Returns(sectionOne);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionOne, startingSection, unassignedRiverSections)).Returns(sectionTwo);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionTwo, sectionOne, unassignedRiverSections)).Returns(sectionThree);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionThree, sectionTwo, unassignedRiverSections)).Returns(sectionFour);

            var riverBuilder = Container.Resolve <RiverBuilder>();

            CollectionAssert.AreEqual(
                new List <RiverSection>()
            {
                startingSection, sectionOne, sectionTwo, sectionThree
            },
                riverBuilder.BuildRiverFromSection(startingSection, unassignedRiverSections)
                );
        }
Beispiel #8
0
        public void BuildRiverFromSection_RemovesAllAddedSectionsFromUnassignedRiverSections()
        {
            var startingSection = new RiverSection();

            var sectionOne   = new RiverSection();
            var sectionTwo   = new RiverSection();
            var sectionThree = new RiverSection();
            var sectionFour  = new RiverSection();

            var unassignedRiverSections = new HashSet <RiverSection>()
            {
                sectionOne, sectionTwo, sectionThree, sectionFour, new RiverSection(), new RiverSection()
            };

            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(startingSection, null, unassignedRiverSections)).Returns(sectionOne);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionOne, startingSection, unassignedRiverSections)).Returns(sectionTwo);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionTwo, sectionOne, unassignedRiverSections)).Returns(sectionThree);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionThree, sectionTwo, unassignedRiverSections)).Returns(sectionFour);

            var riverBuilder = Container.Resolve <RiverBuilder>();

            riverBuilder.BuildRiverFromSection(startingSection, unassignedRiverSections);

            Assert.AreEqual(2, unassignedRiverSections.Count, "Unexpected number of unassigned sections left");

            Assert.IsFalse(unassignedRiverSections.Contains(startingSection), "UnassignedRiverSections unexpectedly contains startingSection");
            Assert.IsFalse(unassignedRiverSections.Contains(sectionOne), "UnassignedRiverSections unexpectedly contains sectionOne");
            Assert.IsFalse(unassignedRiverSections.Contains(sectionTwo), "UnassignedRiverSections unexpectedly contains sectionTwo");
            Assert.IsFalse(unassignedRiverSections.Contains(sectionThree), "UnassignedRiverSections unexpectedly contains sectionThree");
            Assert.IsFalse(unassignedRiverSections.Contains(sectionFour), "UnassignedRiverSections unexpectedly contains sectionFour");
        }
Beispiel #9
0
        public void BuildRiverFromSection_SetsCurveStatusOfSingleSectionRiver()
        {
            var startingSection = new RiverSection()
            {
                HasPreviousEndpoint = true, HasNextEndpoint = true
            };

            var unassignedRiverSections = new HashSet <RiverSection>();

            var riverBuilder = Container.Resolve <RiverBuilder>();

            var river = riverBuilder.BuildRiverFromSection(startingSection, unassignedRiverSections);

            MockRiverBuilderUtilities.Verify(utilities => utilities.SetCurveStatusOfSection(startingSection, river));
        }
        public bool AreSectionFlowsCongruousTests(AreSectionFlowsCongruousTestData testData)
        {
            var thisSection = new RiverSection()
            {
                DirectionFromOne = testData.ThisSection.DirectionFromOne,
                FlowFromOne      = testData.ThisSection.FlowFromOne
            };

            var otherSection = new RiverSection()
            {
                DirectionFromOne = testData.OtherSection.DirectionFromOne,
                FlowFromOne      = testData.OtherSection.FlowFromOne
            };

            var sectionCanon = Container.Resolve <RiverSectionCanon>();

            return(sectionCanon.AreSectionFlowsCongruous(thisSection, otherSection));
        }
Beispiel #11
0
        public void BuildRiverFromSection_AndSectionHasBothEndpoints_ReturnsListWithStartingSection()
        {
            var startingSection = new RiverSection()
            {
                HasPreviousEndpoint = true, HasNextEndpoint = true
            };

            var unassignedRiverSections = new HashSet <RiverSection>();

            var riverBuilder = Container.Resolve <RiverBuilder>();

            CollectionAssert.AreEqual(
                new List <RiverSection>()
            {
                startingSection
            },
                riverBuilder.BuildRiverFromSection(startingSection, unassignedRiverSections)
                );
        }
Beispiel #12
0
        public void BuildRiverFromSection_RemovesSingleSectionRiverFromUnassignedRiverSections()
        {
            var startingSection = new RiverSection()
            {
                HasPreviousEndpoint = true, HasNextEndpoint = true
            };

            var unassignedRiverSections = new HashSet <RiverSection>()
            {
                startingSection, new RiverSection(), new RiverSection()
            };

            var riverBuilder = Container.Resolve <RiverBuilder>();

            riverBuilder.BuildRiverFromSection(startingSection, unassignedRiverSections);

            Assert.AreEqual(2, unassignedRiverSections.Count, "Unexpected number of unassigned sections left");

            Assert.IsFalse(unassignedRiverSections.Contains(startingSection), "UnassignedRiverSections unexpectedly contains startingSection");
        }
Beispiel #13
0
        public void GetNextActiveSectionForRiver_AndNoValidSections_ReturnsNull()
        {
            var center    = BuildCell();
            var left      = BuildCell();
            var right     = BuildCell();
            var nextRight = BuildCell();

            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.NE)).Returns(left);
            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.SE)).Returns(nextRight);

            var activeSection = new RiverSection()
            {
                AdjacentCellOne = center, AdjacentCellTwo = right, DirectionFromOne = HexDirection.E
            };
            var lastSection = new RiverSection();

            var unassignedSections = new HashSet <RiverSection>();

            var utilities = Container.Resolve <RiverBuilderUtilities>();

            Assert.IsNull(utilities.GetNextActiveSectionForRiver(activeSection, lastSection, unassignedSections));
        }
        public void IsNeighborOf_TrueIfOtherSectionIsSectionBetweenRightAndNextRight()
        {
            var center = BuildCell(Vector3.zero, new Dictionary <HexDirection, RiverFlow>()
            {
                { HexDirection.NE, RiverFlow.Clockwise },
                { HexDirection.E, RiverFlow.Clockwise },
                { HexDirection.SE, RiverFlow.Clockwise },
            });

            var left = BuildCell(Vector3.zero, new Dictionary <HexDirection, RiverFlow>()
            {
                { HexDirection.SE, RiverFlow.Clockwise }
            });
            var right = BuildCell(Vector3.zero, new Dictionary <HexDirection, RiverFlow>()
            {
                { HexDirection.E, RiverFlow.Counterclockwise }
            });
            var nextRight = BuildCell(Vector3.zero, new Dictionary <HexDirection, RiverFlow>()
            {
                { HexDirection.NE, RiverFlow.Clockwise }
            });

            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.NE)).Returns(left);
            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.E)).Returns(right);
            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.SE)).Returns(nextRight);

            MockGrid.Setup(grid => grid.GetNeighbor(left, HexDirection.SE)).Returns(right);
            MockGrid.Setup(grid => grid.GetNeighbor(nextRight, HexDirection.NE)).Returns(right);

            var sectionCanon = Container.Resolve <RiverSectionCanon>();

            sectionCanon.RefreshRiverSections();

            RiverSection rightNextRightSection = sectionCanon.Sections[5];
            RiverSection sectionToTest         = sectionCanon.Sections[1];

            Assert.IsTrue(sectionCanon.IsNeighborOf(sectionToTest, rightNextRightSection));
        }
        public void IsNeighborOf_FalseIfOtherSectionNotOneOfTheCheckedSections()
        {
            var center = BuildCell(Vector3.zero, new Dictionary <HexDirection, RiverFlow>()
            {
                { HexDirection.NE, RiverFlow.Clockwise },
                { HexDirection.E, RiverFlow.Clockwise },
                { HexDirection.SE, RiverFlow.Clockwise },
            });

            var left = BuildCell(Vector3.zero, new Dictionary <HexDirection, RiverFlow>()
            {
                { HexDirection.SE, RiverFlow.Clockwise }
            });
            var right = BuildCell(Vector3.zero, new Dictionary <HexDirection, RiverFlow>()
            {
                { HexDirection.E, RiverFlow.Counterclockwise }
            });
            var nextRight = BuildCell(Vector3.zero, new Dictionary <HexDirection, RiverFlow>()
            {
                { HexDirection.NE, RiverFlow.Clockwise }
            });

            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.NE)).Returns(left);
            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.E)).Returns(right);
            MockGrid.Setup(grid => grid.GetNeighbor(center, HexDirection.SE)).Returns(nextRight);

            MockGrid.Setup(grid => grid.GetNeighbor(left, HexDirection.SE)).Returns(right);
            MockGrid.Setup(grid => grid.GetNeighbor(nextRight, HexDirection.NE)).Returns(right);

            var sectionCanon = Container.Resolve <RiverSectionCanon>();

            sectionCanon.RefreshRiverSections();

            RiverSection unattachedSection = sectionCanon.Sections[4];
            RiverSection sectionToTest     = sectionCanon.Sections[1];

            Assert.IsFalse(sectionCanon.IsNeighborOf(sectionToTest, unattachedSection));
        }
Beispiel #16
0
        public void BuildRiverFromSection_SetsCurveStatusOfAllSectionsInRiver()
        {
            var startingSection = new RiverSection();

            var sectionOne   = new RiverSection();
            var sectionTwo   = new RiverSection();
            var sectionThree = new RiverSection();

            var unassignedRiverSections = new HashSet <RiverSection>();

            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(startingSection, null, unassignedRiverSections)).Returns(sectionOne);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionOne, startingSection, unassignedRiverSections)).Returns(sectionTwo);
            MockRiverBuilderUtilities.Setup(utilities => utilities.GetNextActiveSectionForRiver(sectionTwo, sectionOne, unassignedRiverSections)).Returns(sectionThree);

            var riverBuilder = Container.Resolve <RiverBuilder>();

            var river = riverBuilder.BuildRiverFromSection(startingSection, unassignedRiverSections);

            MockRiverBuilderUtilities.Verify(utilities => utilities.SetCurveStatusOfSection(startingSection, river), Times.Once, "Curve status of startingSection not set");
            MockRiverBuilderUtilities.Verify(utilities => utilities.SetCurveStatusOfSection(sectionOne, river), Times.Once, "Curve status of sectionOne not set");
            MockRiverBuilderUtilities.Verify(utilities => utilities.SetCurveStatusOfSection(sectionTwo, river), Times.Once, "Curve status of sectionTwo not set");
            MockRiverBuilderUtilities.Verify(utilities => utilities.SetCurveStatusOfSection(sectionThree, river), Times.Once, "Curve status of sectionThree not set");
        }