public void Three_Steppable_Pillars_Should_Return_One_Item()
            {
                /*
                 * X = lastPosition
                 *
                 *       0   1   2     X axis
                 *  0  |   | 0 |   |
                 *  1  | 2 | X | 2 |
                 *  2  |   | 2 |   |
                 *
                 *  Y
                 *
                 *  a
                 *  x
                 *  i
                 *  s
                 */

                var right = new Pillar(2, 1);

                right.Build();
                right.Build();

                var bottom = new Pillar(1, 2);

                bottom.Build();
                bottom.Build();

                var left = new Pillar(0, 1);

                left.Build();
                left.Build();

                var nearestPillars = new Pillar[4]
                {
                    new Pillar(1, 0),
                    right,
                    bottom,
                    left,
                };

                var lastPosition = new Pillar(1, 1);

                lastPosition.Build();

                var actual = _rules.Steppable(nearestPillars, lastPosition);

                Assert.That(actual, Is.Not.Null);
                Assert.That(actual.Length, Is.EqualTo(3));

                Assert.That(actual[0].X, Is.EqualTo(right.X), "right.X");
                Assert.That(actual[0].Y, Is.EqualTo(right.Y), "right.X");

                Assert.That(actual[1].X, Is.EqualTo(bottom.X), "bottom.X");
                Assert.That(actual[1].Y, Is.EqualTo(bottom.Y), "bottom.X");

                Assert.That(actual[2].X, Is.EqualTo(left.X), "left.X");
                Assert.That(actual[2].Y, Is.EqualTo(left.Y), "left.X");
            }
Beispiel #2
0
        public void SetField_Method()
        {
            var map   = new Map(3);
            var field = new Pillar(1, 2);

            field.Build();
            field.Build();
            map.SetField(field);

            var actual = map.GetField(1, 2);

            Assert.That(actual.X, Is.EqualTo(1), "actual.X");
            Assert.That(actual.Y, Is.EqualTo(2), "actual.Y");
            Assert.That(actual.Height, Is.EqualTo(3), "actual.Height");
        }
            public void No_Steppable_Pillars_Should_Return_Empty_Array()
            {
                /*
                 * X = lastPosition
                 *
                 *       0   1   2     X axis
                 *  0  |   | 0 |   |
                 *  1  | 0 | X | 0 |
                 *  2  |   | 0 |   |
                 *
                 *  Y
                 *
                 *  a
                 *  x
                 *  i
                 *  s
                 */
                var nearestPillars = new Pillar[4]
                {
                    new Pillar(1, 0),
                    new Pillar(2, 1),
                    new Pillar(1, 2),
                    new Pillar(0, 1),
                };

                var lastPosition = new Pillar(1, 1);

                lastPosition.Build();

                var actual = _rules.Steppable(nearestPillars, lastPosition);

                Assert.That(actual, Is.Not.Null);
                Assert.That(actual.Length, Is.EqualTo(0));
            }
        private void Build(Pillar position)
        {
            Model.Step(position);

            position.Build();

            Log.Debug($"BUILD ({position.X}; {position.Y}) Height : {position.Height - 1} -> {_map.GetField(position).Height}", 1);
        }
            public void One_Steppable_Pillars_Should_Return_One_Item()
            {
                /*
                 * X = lastPosition
                 *
                 *       0   1   2     X axis
                 *  0  |   | 0 |   |
                 *  1  | 0 | X | 2 |
                 *  2  |   | 0 |   |
                 *
                 *  Y
                 *
                 *  a
                 *  x
                 *  i
                 *  s
                 */

                var highestPillar = new Pillar(2, 1);

                highestPillar.Build();
                highestPillar.Build();

                var nearestPillars = new Pillar[4]
                {
                    new Pillar(1, 0),
                    highestPillar,
                    new Pillar(1, 2),
                    new Pillar(0, 1),
                };

                var lastPosition = new Pillar(1, 1);

                lastPosition.Build();

                var actual = _rules.Steppable(nearestPillars, lastPosition);

                Assert.That(actual, Is.Not.Null);
                Assert.That(actual.Length, Is.EqualTo(1));

                Assert.That(actual[0].X, Is.EqualTo(highestPillar.X), "highestPillar.X");
                Assert.That(actual[0].Y, Is.EqualTo(highestPillar.Y), "highestPillar.Y");
            }