Example #1
0
        /// <summary>
        /// Обновить видимую область при обычном режиме просмотра планет
        /// </summary>
        private void RefreshNormalVisibleArea()
        {
            var rect = _zoom.GetVisibleRect(_currentCellItemPosition);

            if (_prevRect == null)
            {
                _planets.DestroyAll();

                FillPlanets(rect);
            }
            else
            {
                // Вычтем текущего прямоугольник из прошлого, получив таким образом область для очистки
                var rectsToDestroy = RectIntTool.Subtract(_prevRect.Value, rect);

                for (int i = 0; i < rectsToDestroy.Count; i++)
                {
                    ClearPlanets(rectsToDestroy[i]);
                }

                // Вычтем прошлый прямоугольник из текущего, получив таким образом область для заполнения планетами
                var rectsToFill = RectIntTool.Subtract(rect, _prevRect.Value);

                for (int i = 0; i < rectsToFill.Count; i++)
                {
                    FillPlanets(rectsToFill[i]);
                }
            }

            _prevRect = rect;
        }
Example #2
0
        /// <summary>
        /// Изменилась текущая позиция игрока на поле
        /// </summary>
        private void OnPlayerPositionChanged()
        {
            var newCellPosition = SettingsAccess.GetCellBeginPosition(_currentCellItemPosition);

            // Если изменилась текущая ячейка игрока на поле, добавим разницу между прямоугольниками старых и новых координат игрока на генерацию
            if (newCellPosition != _currentCellPosition)
            {
                var prevRect        = SettingsAccess.GetFieldRectPx(_currentCellPosition);
                var prevVisibleRect = SettingsAccess.GetFullGenerationRect(_currentCellPosition);

                var newRect        = SettingsAccess.GetFieldRectPx(newCellPosition);
                var newVisibleRect = SettingsAccess.GetFullGenerationRect(newCellPosition);

                // Разница между старым прямоугольником всего поля и текущим
                var rectsToFill = RectIntTool.Subtract(newRect, prevRect);
                // Разница между старым прямоугольником полностью генерируемого мира вокруг игрока и текущим
                var visibleRectsFill = RectIntTool.Subtract(newVisibleRect, prevVisibleRect);

                visibleRectsFill.AddRange(rectsToFill);

                if (visibleRectsFill.Count > 0)
                {
                    // Добавить задание на генерацию - сперва прямоугольники полностью генерируемых ячеек вокруг игрока, потом прямоугольники поля
                    _generator.AppendRects(visibleRectsFill, true);
                }

                _currentCellPosition = newCellPosition;
            }

            if (_zoom.IsAdvancedView() == false)
            {
                RefreshNormalVisibleArea();

                SetPosition();
            }
            else
            {
                if (_zoom.IsCellsView())
                {
                    _sortedCellsVisitor.AppendRect(_zoom.GetVisibleRect(_currentCellPosition));
                }
                else
                {
                    _sortedCellsVisitor.AppendRect(_zoom.GetVisibleRect(_currentCellItemPosition));
                }
            }
        }
Example #3
0
        public void SubtractRectangleCheck()
        {
            RectInt[] rects = new RectInt[]
            {
                new RectInt(0, 0, 3, 3),
                new RectInt(1, 1, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(0, 1, 3, 3),
                new RectInt(0, 1, 3, 3),
                new RectInt(1, 0, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(-1, -1, 3, 3),
                new RectInt(-1, -1, 5, 5),
                new RectInt(0, 0, 3, 3)
            };

            RectInt[] subtracts = new RectInt[]
            {
                new RectInt(1, 1, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(0, 1, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(1, 0, 3, 3),
                new RectInt(0, 1, 3, 3),
                new RectInt(0, -1, 3, 3),
                new RectInt(-1, -1, 3, 3),
                new RectInt(3, 3, 3, 3),
                new RectInt(-3, -3, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(0, 0, 3, 3),
                new RectInt(-1, -1, 5, 5)
            };

            RectInt[][] results = new RectInt[][]
            {
                new RectInt[]
                {
                    new RectInt(0, 0, 3, 1),
                    new RectInt(0, 1, 1, 2)
                },
                new RectInt[]
                {
                    new RectInt(3, 1, 1, 3),
                    new RectInt(1, 3, 2, 1)
                },
                new RectInt[]
                {
                    new RectInt(0, 0, 3, 1),
                },
                new RectInt[]
                {
                    new RectInt(0, 3, 3, 1),
                },
                new RectInt[]
                {
                    new RectInt(0, 1, 1, 3),
                    new RectInt(1, 3, 2, 1)
                },
                new RectInt[]
                {
                    new RectInt(1, 0, 3, 1),
                    new RectInt(3, 1, 1, 2)
                },
                new RectInt[]
                {
                    new RectInt(0, 2, 3, 1),
                },
                new RectInt[]
                {
                    new RectInt(2, 0, 1, 3),
                    new RectInt(0, 2, 2, 1)
                },
                new RectInt[] { },
                new RectInt[] { },
                new RectInt[]
                {
                    new RectInt(-1, -1, 3, 1),
                    new RectInt(-1, 0, 1, 2)
                },
                new RectInt[]
                {
                    new RectInt(-1, -1, 5, 1),
                    new RectInt(-1, 0, 1, 4),
                    new RectInt(3, 0, 1, 4),
                    new RectInt(0, 3, 3, 1)
                },
                new RectInt[] { },
            };

            for (int i = 0; i < rects.Length; i++)
            {
                var rect     = rects[i];
                var subtract = subtracts[i];
                var result   = results[i];

                var rectangles = RectIntTool.Subtract(rect, subtract);

                for (int j = 0; j < Mathf.Min(result.Length, rectangles.Count); j++)
                {
                    Assert.AreEqual(rectangles[j], result[j]);
                }

                Assert.AreEqual(result.Length, rectangles.Count);
            }
        }