using System;

using System.IO;

using System.Collections;

using System.Collections.Generic;

using System.Globalization;

using System.Linq;

using System.Security.Cryptography;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Threading;

using System.Xml;

using System.Xml.Linq;

using System.Data.Common;

using System.Text.RegularExpressions;

​

​

namespace NewLife

{

    /// <summary>

    /// Interaktionslogik für MainWindow.xaml

    /// </summary>

    public partial class MainWindow : Window

    {

​

        //--Werte die vom Konstruktor und anderen Klassen geteilt werden--

        int Speed = 500;

        int ClickedRow;

        int ClickedColumn;

        bool GamePlays = false; //Boolean zum pausieren des Spiels

        WindowState oldstate; //sichert die Ansicht des Fenstersc

        Border[] BorderFields = new Border[0]; //erstellt Array mit standartmäßig 0 Objekten (Werden später hinzugefügt)

        BrushConverter bc = new BrushConverter();

​

        static int HowManyColumns = 128;

        static int HowManyRows = 128;

​

        ColumnDefinition[] Columns = new ColumnDefinition[HowManyColumns];

        RowDefinition[] Rows = new RowDefinition[HowManyRows];

​

        //Stacks (wie eine Queue die abgearbietet wird)

        Stack<Tuple<int, int>> KillCells = new Stack<Tuple<int, int>>();

        Stack<Tuple<int, int>> CreateCells = new Stack<Tuple<int, int>>();

​

        //Dictionary welches jedem Feld seine Position im Grid zuweißt --> Tuple<int,int> - int zuweisung

        Dictionary<Tuple<int, int>, int> PositionToField = new Dictionary<Tuple<int, int>, int>();

​

        //Booleans für den Forschritt der Entwicklung von Zellen und Maus/Tast-Schnitstelle

        bool KillingProcessListFinished = false;

        bool PopulationProcessListFinished = false;

​

        bool isShiftKeyPressed = false;

​

        int currentF = -1;

        static int rows;

        static int columns;

        Border[] borders = new Border[0]; //erstellt gebrauchte Anzahl an Borders

​

​

        public MainWindow()

        {

            InitializeComponent();

            Scroller.Focus();

​

            //erstellt Zeilen und Spalten

            for (int i = 0; i < HowManyColumns; i++)

            {

                Columns[i] = new ColumnDefinition();

                Columns[i].Width = new GridLength(35.0, GridUnitType.Pixel);

                Playground.ColumnDefinitions.Add(Columns[i]);

            }

            for (int i = 0; i < HowManyRows; i++)

            {

                Rows[i] = new RowDefinition();

                Rows[i].Height = new GridLength(35.0, GridUnitType.Pixel);

                Playground.RowDefinitions.Add(Rows[i]);

            }

            //Fragt die Anzahl der Rows und Columns ab

            rows = Playground.RowDefinitions.Count;

            columns = Playground.ColumnDefinitions.Count;

​

            //Passt Größe des Arrays an

            Array.Resize(ref borders, rows*columns);

​

​

            //Erstellung der Grenzlinien der Felder

            int col = 0;

            int ro = 0;

            for (int i = 0; i < rows * columns; i++)

            {

                if (col == columns)

                {

                    col = 0;

                    ro++;

                }

                borders[i] = new Border();

                borders[i].Visibility = Visibility.Visible;

                borders[i].BorderThickness = new Thickness(1, 1, 1, 1);

                borders[i].BorderBrush = (Brush)bc.ConvertFrom("#FAF300");

​

                Grid.SetColumn(borders[i], col);

                Grid.SetRow(borders[i], ro);

​

                Playground.Children.Add(borders[i]);

                col++;

​

            }

        }

​

        //Verteilt die ordinalen Zahlen der "BorderFields"

        public int GetField()

        {

            currentF++;

            //erweitert den Array in 10er Schritten

            if (currentF % 10 == 0 || currentF==0)               

                Array.Resize(ref BorderFields, BorderFields.Length + 10);

            return currentF;

        }

​

        //Methode zum systematischen Erstellen von spezifischen Feldern

        void CreateNewBorderField(int SetColumnPosition, int SetRowPosition)

        {

            if (!PositionToField.ContainsKey(new Tuple<int, int>(SetColumnPosition, SetRowPosition)) && SetColumnPosition >= 0 && SetRowPosition >= 0) //Überprüft ob das/die Feld/Zelle schon existiert

            {

                int NumberOfCurrentField = GetField();

                BorderFields[NumberOfCurrentField] = new Border();

​

                BorderFields[NumberOfCurrentField].Background = (Brush)bc.ConvertFrom("#3FF026");

                BorderFields[NumberOfCurrentField].Visibility = Visibility.Visible;

​

                Grid.SetColumn(BorderFields[NumberOfCurrentField], SetColumnPosition);

                Grid.SetRow(BorderFields[NumberOfCurrentField], SetRowPosition);

                Playground.Children.Add(BorderFields[NumberOfCurrentField]);

​

                Tuple<int, int> DictTuple = new Tuple<int, int>(SetColumnPosition, SetRowPosition);

                PositionToField.Add(DictTuple, NumberOfCurrentField);

            }

        }

​

        //Methode zum Löschen der Felder

        void DeleteBorderFields(int ColumnPosition, int RowPosition)

        {

            if (PositionToField.ContainsKey(new Tuple<int, int>(ColumnPosition, RowPosition)))

            {

                Tuple<int, int> DelTuple = new Tuple<int, int>(ColumnPosition, RowPosition);

                int NumberOfCurrentField = PositionToField[DelTuple];

                Playground.Children.Remove(BorderFields[NumberOfCurrentField]);

                BorderFields[NumberOfCurrentField] = null;

​

                PositionToField.Remove(DelTuple);

            }

        }

​

        //Zählt die Nachbarn und Entscheidet ob die Zelle getötet wird

        void Security()

        {

            int count;

            Tuple<int, int> CheckTuple = new Tuple<int, int>(-1, -1);

            Tuple<int, int> currentTuple = new Tuple<int, int>(-1, -1);

​

            foreach (KeyValuePair<Tuple<int, int>, int> Field in PositionToField)

            {

                count = 0;

​

                //checkt nach links

                CheckTuple = new Tuple<int, int>(Field.Key.Item1 - 1, Field.Key.Item2);

                if (PositionToField.ContainsKey(CheckTuple))

                    count++;

​

                //checkt nach rechts

                CheckTuple = new Tuple<int, int>(Field.Key.Item1 + 1, Field.Key.Item2);

                if (PositionToField.ContainsKey(CheckTuple))

                    count++;

​

                //nach oben

                CheckTuple = new Tuple<int, int>(Field.Key.Item1, Field.Key.Item2 - 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    count++;

​

                //nach unten

                CheckTuple = new Tuple<int, int>(Field.Key.Item1, Field.Key.Item2 + 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    count++;

​

                //nach oben links

                CheckTuple = new Tuple<int, int>(Field.Key.Item1 - 1, Field.Key.Item2 - 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    count++;

​

                //nach links unten

                CheckTuple = new Tuple<int, int>(Field.Key.Item1 - 1, Field.Key.Item2 + 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    count++;

​

                //nach rechts unten

                CheckTuple = new Tuple<int, int>(Field.Key.Item1 + 1, Field.Key.Item2 + 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    count++;

​

                //nach rechts oben

                CheckTuple = new Tuple<int, int>(Field.Key.Item1 + 1, Field.Key.Item2 - 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    count++;

​

                if (count > 3 || count < 2)

                {

                    currentTuple = new Tuple<int, int>(Field.Key.Item1, Field.Key.Item2);

                    KillCells.Push(currentTuple);

                }

            }

            //Alle Zellen wurden bearbeitet

            KillingProcessListFinished = true;

​

        }

​

        //prüft jedes Feld ob es genau 3 Nachbarzellen hat

        void Population()

        {

            int CountPopulation;

            int currentColumn;

            int currentRow;

​

            Tuple<int, int> currentPopTuple = new Tuple<int, int>(-1,-1);

            Tuple<int, int> CheckTuple = new Tuple<int, int>(- 1, -1);

            Tuple<int, int> creatTuple = new Tuple<int, int>(-1, -1);

​

            foreach (Border CheckBorder in borders)

            {

                currentColumn = Grid.GetColumn(CheckBorder);

                currentRow = Grid.GetRow(CheckBorder);

                currentPopTuple = new Tuple<int, int>(currentColumn, currentRow);

                if (PositionToField.ContainsKey(currentPopTuple))

                {

                    continue;

                }

                CountPopulation = 0;

​

                //checkt nach links

                CheckTuple = new Tuple<int, int>(currentColumn - 1, currentRow);

                if (PositionToField.ContainsKey(CheckTuple))

                    CountPopulation++;

​

​

                //checkt nach rechts

                CheckTuple = new Tuple<int, int>(currentColumn + 1, currentRow);

                if (PositionToField.ContainsKey(CheckTuple))

                    CountPopulation++;

​

                //nach oben

                CheckTuple = new Tuple<int, int>(currentColumn, currentRow - 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    CountPopulation++;

​

                //nach unten

                CheckTuple = new Tuple<int, int>(currentColumn, currentRow + 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    CountPopulation++;

​

                //nach oben rechts

                CheckTuple = new Tuple<int, int>(currentColumn - 1, currentRow - 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    CountPopulation++;

​

                //nach links unten

                CheckTuple = new Tuple<int, int>(currentColumn - 1, currentRow + 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    CountPopulation++;

​

                //nach rechts unten

                CheckTuple = new Tuple<int, int>(currentColumn + 1, currentRow + 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    CountPopulation++;

​

                //nach rechts oben

                CheckTuple = new Tuple<int, int>(currentColumn + 1, currentRow - 1);

                if (PositionToField.ContainsKey(CheckTuple))

                    CountPopulation++;

​

                if (CountPopulation == 3)

                {

                    creatTuple = new Tuple<int, int>(currentColumn, currentRow);

                    CreateCells.Push(creatTuple);

                }

            }

            //Alle Felder wurden geprüft

            PopulationProcessListFinished = true;

​

        }

​

        //Tötet oder erschafft die Zellen aus "population()" und "security()"

        async Task Excecute()

        {

            Security();

            Population();

            while (GamePlays)

            {

                if (PopulationProcessListFinished && KillingProcessListFinished)

                {

                    PopulationProcessListFinished = false;

                    KillingProcessListFinished = false;

​

                    //Tötung der Zellen

                    int AmountOfCells = KillCells.Count;

                    for (int i = 0; i < AmountOfCells; i++)

                    {

                        Tuple<int, int> KillTuple = KillCells.Pop();

                        DeleteBorderFields(KillTuple.Item1, KillTuple.Item2);

                    }

                    //Erschaffung der Zellen

                    AmountOfCells = CreateCells.Count;

                    for (int i = 0; i < AmountOfCells; i++)

                    {

                        Tuple<int, int> CreationTuple = CreateCells.Pop();

                        CreateNewBorderField(CreationTuple.Item1, CreationTuple.Item2);

                    }

                    Security();

                    Population();

                }

                await Task.Delay(Speed);

​

​

            }

        }

​

        //erstellt oder löscht Zellen bei den angeklickten Feldern

        async void Clicked()

        {

            if (!PositionToField.ContainsKey(new Tuple<int, int>(ClickedColumn, ClickedRow)))

            {

                CreateNewBorderField(ClickedColumn, ClickedRow);

                PopulationProcessListFinished = false;

                KillingProcessListFinished = false;

                KillCells.Clear();

                CreateCells.Clear();

                Security();

                Population();

                ClickedColumn = -1;

                ClickedRow = -1;

​

            }

            else

            {

                DeleteBorderFields(ClickedColumn, ClickedRow);

                PopulationProcessListFinished = false;

                KillingProcessListFinished = false;

                KillCells.Clear();

                CreateCells.Clear();

                Security();

                Population();

                ClickedColumn = -1;

                ClickedRow = -1;

            }

            await Task.Delay(TimeSpan.FromMilliseconds(0.5));

​

        }

        //erstellt zufällige Felder

        async void Random()

        {

            Random rand = new Random();

            for (int i = 0; i < (rows*columns)/3; i++)

            {

                int currentColumn = rand.Next(0, columns);

                int currentRow = rand.Next(0, rows);

                CreateNewBorderField(currentColumn, currentRow);

            }

            await Task.Delay(TimeSpan.FromMilliseconds(0.5));

​

        }

​

        public void maingrid_MouseDown(object sender, MouseButtonEventArgs e)

        {

            //DragMove

            if (e.LeftButton == MouseButtonState.Pressed)

            {

                DragMove();

            }

            else if (e.RightButton == MouseButtonState.Pressed)

            {

​

                var point = Mouse.GetPosition(Playground);

​

                int Clrow = 0;

                int Clcol = 0;

                double accumulatedHeight = 0.0;

                double accumulatedWidth = 0.0;

​

                //errechnet die GridZeile über der die Maus beim Klick war

                foreach (var rowDefinition in Playground.RowDefinitions)

                {

                    accumulatedHeight += rowDefinition.ActualHeight;

                    if (accumulatedHeight >= point.Y)

                        break;

                    Clrow++;

                }

​

                //errechnet die GridSpalte über der die Maus beim Klick war

                foreach (var columnDefinition in Playground.ColumnDefinitions)

                {

                    accumulatedWidth += columnDefinition.ActualWidth;

                    if (accumulatedWidth >= point.X)

                        break;

                    Clcol++;

                }

                ClickedColumn = Clcol;

                ClickedRow = Clrow;

                Clicked();

            }

​

        }

​

        //Weitere Eingaben werden Verarbeitet

        public void maingrid_KeyDown(object sender, KeyEventArgs e)

        {

            if (e.Key == Key.F)

            {

​

                if (!(WindowState == WindowState.Maximized))

                {

                    oldstate = WindowState;

                    WindowState = WindowState.Maximized;

                    Visibility = Visibility.Collapsed;

                    WindowStyle = WindowStyle.None;

                    Visibility = Visibility.Visible;

​

                }

                else

                    WindowState = oldstate;

            }

            else if (e.Key == Key.Space)

            {

                GamePlays = !GamePlays;

                if (GamePlays)

                    Excecute();

​

            }

​

            else if (e.Key == Key.Delete)

            {

                oldstate = WindowState;

                MainWindow mainWindow = new MainWindow();

                mainWindow.Show();

                mainWindow.WindowState = oldstate;

                this.Close();

            }

​

            else if (e.Key == Key.F1)

            {

                if (Speed > 100)

                    Speed -= 100;

            }

            else if (e.Key == Key.F2)

                Speed += 100;

            else if (e.Key == Key.C)

            {

                Scroller.ScrollToHorizontalOffset(Scroller.ScrollableWidth / 2);

                Scroller.ScrollToVerticalOffset(Scroller.ScrollableHeight / 2);

            }

            else if (e.Key == Key.R)

                Random();

            else if (e.Key == Key.O)

                RLE();

            else if (e.Key == Key.Escape)

                this.Close();

            else if (e.Key == Key.Back)

                this.WindowState = WindowState.Minimized;

        }

​

        //Bewegung im Scrollberreich

        void Scroller_PreviewMouseWheel(object sender, MouseWheelEventArgs e)

        {

            e.Handled = true;

​

            if (isShiftKeyPressed)

            {

                //horizontal

                if (e.Delta > 0)

                {

                    //links

                    Scroller.ScrollToHorizontalOffset(Scroller.HorizontalOffset - 30);

                }

                else

                {

                    //rechts

                    Scroller.ScrollToHorizontalOffset(Scroller.HorizontalOffset + 30);

                }

            }

            else if (!isShiftKeyPressed && !(Keyboard.Modifiers == ModifierKeys.Control))

            {

                //vertikal

                if (e.Delta > 0)

                {

                    //hoch

                    Scroller.ScrollToVerticalOffset(Scroller.VerticalOffset - 30);

                }

                else

                {

                    //runter

                    Scroller.ScrollToVerticalOffset(Scroller.VerticalOffset + 30);

                }

            }

            //Zoom

            else if (Keyboard.Modifiers == ModifierKeys.Control)

            {

                e.Handled = true;

​

                double zoomDelta = e.Delta > 0 ? 0.01 : -0.01;

                double newZoom = Scroller.LayoutTransform.Value.M11 + zoomDelta;

​

                if (newZoom < 0.1 || newZoom > 10.0)

                {

                    return;

                }

​

                Matrix matrix = Scroller.LayoutTransform.Value;

                matrix.ScaleAtPrepend(newZoom / matrix.M11, newZoom / matrix.M11, e.GetPosition(Playground).X, e.GetPosition(Playground).Y);

                Scroller.LayoutTransform = new MatrixTransform(matrix);

            }

        }

​

        //Abfragen für die vertikale/horizontale Bewegung

        private void Scroller_KeyDown(object sender, KeyEventArgs e)

        {

            if (e.Key == Key.LeftShift)

            {

                isShiftKeyPressed = true;

            }

        }

        private void Scroller_KeyUp(object sender, KeyEventArgs e)

        {

            if (e.Key == Key.LeftShift)

            {

                isShiftKeyPressed = false;

            }

        }

​

        void RLE()

        {

​

            string fileName = "cgol.rle";

            string desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);

            string filePath = Path.Combine(desktopPath, fileName);

​

            if (!File.Exists(filePath))

            {

                MessageBox.Show("Datei nicht gefunden!");

                return;

            }

​

            string fileContents = File.ReadAllText(filePath);

​

            //Extrahiert die Daten der ersten Zeile

            Match match = Regex.Match(fileContents, @"x\s*=\s*(\d+),\s*y\s*=\s*(\d+)");

            int width = int.Parse(match.Groups[1].Value);

            int height = int.Parse(match.Groups[2].Value);

​

​

            // Speicherungsarray 

            bool[,] grid = new bool[width, height];

​

            //Array mit StrukturDaten

            string[] lines = fileContents.Split('\n');

            int x = 0;

            int y = 0;

            int count = 0;

            foreach (string line in lines)

            {

                if (line.StartsWith("#")) // Kommentare 

                    continue;

                else if (line.StartsWith("x")) // Erste Reihe

                    continue;

​

                int posInLine = -1;

                foreach (char c in line)

                {

                    posInLine++;

                    if (char.IsDigit(c))

                    {

                        if (count == 0)

                        {

                            count = Convert.ToInt32(Convert.ToString(c));

​

                        }

                        else if (count > 0)

                        {

                            count = Convert.ToInt32(Convert.ToString(count) + line[posInLine]);

                        }

                    }

                    else if (c == 'b')

                    {

                        if (count > 0)

                        {

                            for (int l = count; l > 0; l--)

                            {

                                grid[x++, y] = false;

                            }

                            count = 0;

                        }

                        else if (x < width && y < height)

                            grid[x++, y] = false;

                    }

                    else if (c == 'o')

                    {

                        if (count > 0)

                        {

                            for (int l = count; l > 0; l--)

                            {

                                grid[x++, y] = true;

                            }

                            count = 0;

                        }

​

                        else if (x < width && y < height)

                            grid[x++, y] = true;

                    }

                    else if (c == '$')

                    {

                        if (count > 0)

                        {

                            for (int l = count; l > 0; l--)

                            {

                                x = 0;

                                y++;

                            }

                            count = 0;

                        }

                        else

                        {

                            x = 0;

                            y++;

                        }

​

                    }

                }

            }

​

            int orientCol = (columns / 2) - (height / 2);

​

            int orientRow = (rows / 2) - (width / 2);

            if (orientCol+height>=columns)

            {

                orientCol = 5;

            }

            if (orientRow+width>=rows)

            {

                orientRow = 5;

            }

            for (int j = 0; j < height; j++)

            {

                for (int k = 0; k < width; k++)

                {

                    if (grid[k, j])

                    {

                        CreateNewBorderField(k + orientRow, j + orientCol);

                    }

                }

            }

​

        }

​

    }

}

​