Example #1
0
        private void ExecuteTileAction(ArenaCoord tile)
        {
            switch (tileAction)
            {
            case TileAction.Height:
                SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y] = heightSelectorValue;
                SpawnsetHandler.Instance.HasUnsavedChanges = true;

                UpdateTile(tile);

                SetHeightText(SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y]);
                break;

            case TileAction.Select:
                if (!selections.Contains(tile))
                {
                    selections.Add(tile);
                    UpdateTileSelection(tile);
                }
                break;

            case TileAction.Deselect:
                if (selections.Contains(tile))
                {
                    selections.Remove(tile);
                    UpdateTileSelection(tile);
                }
                break;
            }
        }
Example #2
0
        private void ArenaTiles_MouseMove(object sender, MouseEventArgs e)
        {
            Point mousePosition = Mouse.GetPosition((IInputElement)sender);

            SelectionEffect.MousePosition  = new Point(mousePosition.X / arenaCanvasSize, mousePosition.Y / arenaCanvasSize);
            SelectionEffect.HighlightColor = TileUtils.GetColorFromHeight(heightSelectorValue).ToPoint4D(0.5f);
            UpdateSelectionEffectContinuousValues();

            focusedTile = new ArenaCoord(MathUtils.Clamp((int)mousePosition.X / TileUtils.TileSize, 0, Spawnset.ArenaWidth - 1), MathUtils.Clamp((int)mousePosition.Y / TileUtils.TileSize, 0, Spawnset.ArenaHeight - 1));
            if (focusedTile == focusedTilePrevious)
            {
                return;
            }

            Canvas.SetLeft(CursorRectangle, focusedTile.X * TileUtils.TileSize);
            Canvas.SetTop(CursorRectangle, focusedTile.Y * TileUtils.TileSize);

            TileCoordLabel.Content = focusedTile.ToString();
            SetHeightText(SpawnsetHandler.Instance.spawnset.ArenaTiles[focusedTile.X, focusedTile.Y]);

            if (continuous)
            {
                ExecuteTileAction(focusedTile);
            }

            if (rectangleStart.HasValue)
            {
                MultiSelectRectLeft.Visibility   = Visibility.Visible;
                MultiSelectRectRight.Visibility  = Visibility.Visible;
                MultiSelectRectTop.Visibility    = Visibility.Visible;
                MultiSelectRectBottom.Visibility = Visibility.Visible;

                MultiSelectRectLeft.X1 = Math.Min(rectangleStart.Value.X, focusedTile.X) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectLeft.X2 = Math.Min(rectangleStart.Value.X, focusedTile.X) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectLeft.Y1 = Math.Min(rectangleStart.Value.Y, focusedTile.Y) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectLeft.Y2 = Math.Max(rectangleStart.Value.Y, focusedTile.Y) * TileUtils.TileSize + TileUtils.TileSize / 2;

                MultiSelectRectRight.X1 = Math.Max(rectangleStart.Value.X, focusedTile.X) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectRight.X2 = Math.Max(rectangleStart.Value.X, focusedTile.X) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectRight.Y1 = Math.Min(rectangleStart.Value.Y, focusedTile.Y) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectRight.Y2 = Math.Max(rectangleStart.Value.Y, focusedTile.Y) * TileUtils.TileSize + TileUtils.TileSize / 2;

                MultiSelectRectTop.X1 = Math.Min(rectangleStart.Value.X, focusedTile.X) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectTop.X2 = Math.Max(rectangleStart.Value.X, focusedTile.X) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectTop.Y1 = Math.Min(rectangleStart.Value.Y, focusedTile.Y) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectTop.Y2 = Math.Min(rectangleStart.Value.Y, focusedTile.Y) * TileUtils.TileSize + TileUtils.TileSize / 2;

                MultiSelectRectBottom.X1 = Math.Min(rectangleStart.Value.X, focusedTile.X) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectBottom.X2 = Math.Max(rectangleStart.Value.X, focusedTile.X) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectBottom.Y1 = Math.Max(rectangleStart.Value.Y, focusedTile.Y) * TileUtils.TileSize + TileUtils.TileSize / 2;
                MultiSelectRectBottom.Y2 = Math.Max(rectangleStart.Value.Y, focusedTile.Y) * TileUtils.TileSize + TileUtils.TileSize / 2;
            }

            focusedTilePrevious = focusedTile;
        }
Example #3
0
        private void ExecuteTileSelectionAction(ArenaCoord tile)
        {
            switch (tileSelection)
            {
            case TileSelection.Continuous:
                continuous = true;
                break;

            case TileSelection.Rectangle:
                rectangleStart = tile;
                break;
            }
        }
Example #4
0
        private void UpdateTileSelection(ArenaCoord tile)
        {
            bool selected = selections.Contains(tile);

            byte[] pixelBytes = new byte[TileUtils.TileSize * TileUtils.TileSize];
            for (int i = 0; i < pixelBytes.Length; i++)
            {
                pixelBytes[i] = selected ? (byte)0xFF : (byte)0x00;
            }
            normalMap.WritePixels(new Int32Rect(tile.X * TileUtils.TileSize, tile.Y * TileUtils.TileSize, TileUtils.TileSize, TileUtils.TileSize), pixelBytes, TileUtils.TileSize, 0);

            RandomizeHeightsButton.IsEnabled = selections.Count != 0;
            RoundHeightsButton.IsEnabled     = selections.Count != 0;
        }
Example #5
0
        private void SelectAll_Click(object sender, RoutedEventArgs e)
        {
            for (int i = 0; i < Spawnset.ArenaWidth; i++)
            {
                for (int j = 0; j < Spawnset.ArenaHeight; j++)
                {
                    ArenaCoord coord = new ArenaCoord(i, j);
                    if (!selections.Contains(coord))
                    {
                        selections.Add(coord);
                    }
                }
            }

            byte[] pixelBytes = new byte[TileUtils.TileSize * TileUtils.TileSize * Spawnset.ArenaWidth * Spawnset.ArenaHeight];
            for (int i = 0; i < pixelBytes.Length; i++)
            {
                pixelBytes[i] = 0xFF;
            }
            normalMap.WritePixels(new Int32Rect(0, 0, TileUtils.TileSize * Spawnset.ArenaWidth, TileUtils.TileSize * Spawnset.ArenaHeight), pixelBytes, TileUtils.TileSize * Spawnset.ArenaWidth, 0);

            RandomizeHeightsButton.IsEnabled = true;
            RoundHeightsButton.IsEnabled     = true;
        }
Example #6
0
        public void UpdateTile(ArenaCoord tile)
        {
            // Lock special cases if set in settings.
            if (tile == TileUtils.GlitchTile)
            {
                if (UserHandler.Instance.settings.LockGlitchTile)
                {
                    SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y] = Math.Min(SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y], TileUtils.GlitchTileMax);
                }

                App.Instance.MainWindow.WarningGlitchTile.Visibility = SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y] > TileUtils.GlitchTileMax ? Visibility.Visible : Visibility.Collapsed;
            }
            else if (tile == TileUtils.SpawnTile)
            {
                if (UserHandler.Instance.settings.LockSpawnTile)
                {
                    SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y] = Math.Max(SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y], TileUtils.TileMin);
                }

                App.Instance.MainWindow.WarningVoidSpawn.Visibility = SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y] < TileUtils.TileMin ? Visibility.Visible : Visibility.Collapsed;
            }

            // Set tile color.
            float height = SpawnsetHandler.Instance.spawnset.ArenaTiles[tile.X, tile.Y];

            Rectangle rect = tileElements[tile.X, tile.Y];

            if (height < TileUtils.TileMin)
            {
                rect.Visibility = Visibility.Hidden;
                return;
            }
            rect.Visibility = Visibility.Visible;

            Color color = TileUtils.GetColorFromHeight(height);

            rect.Fill = new SolidColorBrush(color);

            // Set tile size.
            double distance = tile.GetDistanceToCanvasPointSquared(arenaCanvasCenter);

            if (distance <= ShrinkCurrent.Width * ShrinkCurrent.Width / 4)
            {
                if (rect.Width == TileUtils.TileSize)
                {
                    return;
                }

                rect.Width  = TileUtils.TileSize;
                rect.Height = TileUtils.TileSize;

                Canvas.SetLeft(rect, tile.X * TileUtils.TileSize);
                Canvas.SetTop(rect, tile.Y * TileUtils.TileSize);
            }
            else
            {
                if (rect.Width == TileUtils.TileSizeShrunk)
                {
                    return;
                }

                rect.Width  = TileUtils.TileSizeShrunk;
                rect.Height = TileUtils.TileSizeShrunk;

                int offset = (TileUtils.TileSize - TileUtils.TileSizeShrunk) / 2;
                Canvas.SetLeft(rect, tile.X * TileUtils.TileSize + offset);
                Canvas.SetTop(rect, tile.Y * TileUtils.TileSize + offset);
            }
        }