Пример #1
0
        /// <summary>
        /// Cycles through the game starting at generation 0 up to the number of generations set in the Settings
        /// </summary>
        public void CycleThroughGame()
        {
            SetInitialState();
            grid.InitializeWindow();
            Stopwatch watch = new Stopwatch();

            for (int i = 0; i <= settings.Generations; i++)
            {
                grid.SetFootnote($"Generation: {i}");

                // Only need to create a new generation from i = 1 onwards
                if (i != 0)
                {
                    statusArray = CreateNextGeneration();
                }
                UpdateCellStatus();
                int matchIndex = CompareToMemory();

                // Only need to compare to memory from i = 1 onwards
                if (i != 0)
                {
                    if (matchIndex != -1)
                    {
                        periodicity = i - generationInMemory[matchIndex];
                        steadyState = true;
                        // Break out of loop to end game
                        break;
                    }
                }
                AddToMemory(statusArray, i);
                grid.Render();
                watch.Restart();

                // User cycles through 1 generation at a time by pressing space if step mode enabled
                if (settings.StepMode)
                {
                    CheckForSpace(writeMsg: false);
                }
                // Otherwise game cycles through at the update rate specified in Settings
                else
                {
                    while (watch.ElapsedMilliseconds < ((1 / settings.UpdateRate) * 1000))
                    {
                        ;
                    }
                }
            }

            // Write final array to file if valid output file path specified
            if (settings.OutputFile != null)
            {
                WriteToFile();
            }
        }
Пример #2
0
        /// <summary>
        /// Main method, which runs the entire program and calls external methods found above and below Main.
        /// </summary>
        /// <author>Zac Wolter</author>
        /// <date>September 2020</date>
        static void Main(string[] args)
        {
            int periodicity = 0;

            // Check for command line arguments...
            Console.WriteLine("Interpreting command line arguments...");
            if (args.Length == 0)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("[SUCCESS] No command line arguments found.");
                Console.ForegroundColor = ConsoleColor.White;
                Console.WriteLine("The program will use the following default settings.");

                //Call the WriteValues method with no parameters, hence printing default set values
                WriteFinalValues();
            }
            // If command line arguments exist, perform the for loop to check each value
            else if (args.Length > 0)
            {
                for (int i = 0; i < args.Length; i++)
                {
                    // Check if the current value contains the dimensions flag
                    if (args[i].Contains("--dimensions"))
                    {
                        DimensionArgCheck(args);
                    }

                    // Check if the current value contains the survival flag
                    else if (args[i].Contains("--survival"))
                    {
                        SurvivalArgCheck(args);
                    }

                    // Check if the current value contains the survival flag
                    else if (args[i].Contains("--birth"))
                    {
                        BirthArgCheck(args);
                    }

                    //Check for periodic behaviour boolean
                    else if (args[i].Contains("--periodic"))
                    {
                        PerioidicArgCheck();
                    }

                    //Check for Random Factor double
                    else if (args[i].Contains("--random"))
                    {
                        RandomArgCheck(args, i);
                    }

                    // Check for seed argument
                    else if (args[i].Contains("--seed"))
                    {
                        SeedFileCheck(args, i);
                    }

                    // Check for generations argument
                    else if (args[i].Contains("--generations"))
                    {
                        GenerationArgCheck(args, i);
                    }

                    // Check for maximum update rate
                    else if (args[i].Contains("--max-update"))
                    {
                        MaxUpdateArgCheck(args, i);
                    }

                    // Check for step mode value
                    else if (args[i].Contains("--step"))
                    {
                        StepArgCheck();
                    }

                    // Check for neighbourhood value
                    else if (args[i].Contains("--neighbour"))
                    {
                        NeighourhoodCheck(args, i, currentValues.Rows, currentValues.Columns);
                    }

                    // Check for memory value
                    else if (args[i].Contains("--memory"))
                    {
                        MemoryArgCheck(args, i);
                    }

                    // Check for ghost mode value
                    else if (args[i].Contains("--ghost"))
                    {
                        GhostArgCheck();
                    }

                    // Check for output file value
                    else if (args[i].Contains("--output"))
                    {
                        OutputFileCheck(args, i);
                    }
                }

                // Check that the given survival and birth values supplied by the user are less than or equal to the number
                // of neighbourhing cells depending on the neighbourhood type
                CheckSurvivalAndBirthValues(currentValues);

                // Check that the given neighbourhood order supplied by the user is less than or equal to half the shortest
                // grid dimension
                NeighbourhoodOrderCheck(currentValues.NeighbourhoodSize, currentValues.Rows, currentValues.Columns);

                WriteFinalValues();
            }

            CLA paramValues = storedValues();

            // Wait until the user presses the spacebar before beginning the simulation
            Console.WriteLine("Press Spacebar to begin.");
            WaitForSpacebarPress();

            int[,,] currentCells = new int[currentValues.Rows, currentValues.Columns, currentValues.Memory];
            int[,,] newCells     = new int[currentValues.Rows, currentValues.Columns, 1];

            // HOW THE NEW 3D ARRAY WILL WORK:
            // EACH CELL: { x, y, z}
            // Where:
            // x = x coordinate
            // y = y coordinate
            // z = generation

            // Seed file initialisation or random seed generation
            if (currentValues.InputFile == "N/A")
            {
                currentCells = GenerateRandomGrid(currentValues.Probability, currentCells, currentValues.Rows,
                                                  currentValues.Columns);
            }
            else
            {
                currentCells = CheckAndInitialiseInputFile(currentValues.InputFilePath, currentCells, currentValues.Rows, currentValues.Columns);
            }

            // Construct grid...
            Grid grid = new Grid(currentValues.Rows, currentValues.Columns);

            // Initialize the grid window (this will resize the window and buffer)
            grid.InitializeWindow();

            // Set the footnote (appears in the bottom left of the screen).
            grid.SetFootnote($"Generation: 0");

            Stopwatch watch = new Stopwatch();

            // Initialise cells
            InitialiseFirstGen(grid, currentCells);

            // Render updates to the console window...
            grid.Render();

            // Integer to keep track of the number of iterations
            int iterations = Convert.ToInt32(currentValues.Generations);
            int passes     = 0;

            // Calculate speed of simulation (applies only if step mode is off)
            int updateTime = 1000 / Convert.ToInt32(currentValues.MaxRefreshRate);

            // Run the simulation
            while (passes < iterations)
            {
                watch.Restart();

                grid.SetFootnote($"Generation: {passes}");
                grid.Render();

                passes++;

                // Check all x layers for any similarities against all other layers
                periodicity = steadyStateCheck(currentCells);

                if (periodicity != -1)
                {
                    steadyStateCompletion(grid, periodicity, currentCells);
                    break;
                }

                // Method that checks every cell in the grid for alive neighbours, decides if each cell is alive or
                // dead in the next generation, and updates the display based on if ghost mode is activated or not
                SimulateNextGen(currentValues.GhostMode, currentCells, grid, newCells);

                // Generates a new array of cells with the previous layers moved forward 1 layer
                // First layer [0] is empty
                currentCells = RotateMemory(currentCells, newCells);

                // Check if step mode is enabled, if so, wait for key press
                if (currentValues.StepMode == true)
                {
                    while (Console.ReadKey(true).Key != ConsoleKey.Spacebar)
                    {
                        ;
                    }
                }
                else
                {
                    // Update timer if required...
                    while (watch.ElapsedMilliseconds < updateTime)
                    {
                        ;
                    }
                }
            }

            grid.SetFootnote("Press Space to Exit");

            // Set complete marker as true
            grid.IsComplete = true;

            // Render updates to the console window (grid should now display COMPLETE)...
            grid.Render();

            // Wait for user to press a key...
            while (true)
            {
                var keyPress = Console.ReadKey(true);
                if (keyPress.Key == ConsoleKey.Spacebar)
                {
                    break;
                }
            }

            // Revert grid window size and buffer to normal
            grid.RevertWindow();

            // Tell user that no steady-state was detected (this code will only execute if the number of generations
            // is reached before a steady-state occurs)
            Console.WriteLine("Steady-state not detected...");

            if (currentValues.OutputFile != "N/A")
            {
                GenerateOutputFile(currentValues.OutputFile, currentValues.Rows, currentValues.Columns, currentCells);
            }

            Console.WriteLine("Press spacebar to close program...");

            // Wait for user to press spacebar...
            while (true)
            {
                var keyPress = Console.ReadKey(true);
                if (keyPress.Key == ConsoleKey.Spacebar)
                {
                    break;
                }
            }

            // Close the program here
            Environment.Exit(0);
        }
Пример #3
0
        static void Main(string[] args)
        {
            Options options = ArgumentProcessor.Process(args);

            int[,] universe = InitializeUniverse(options);
            Grid grid                    = new Grid(options.Rows, options.Columns);
            var  universeList            = new List <int[, ]>();
            bool isSteadyState           = false;
            bool successfullyWroteToFile = false;



            Logging.Message("Press spacebar to begin the game...");
            WaitSpacebar();

            grid.InitializeWindow();


            Stopwatch stopwatch = new Stopwatch();

            int iteration = 0;

            while (iteration <= options.Generations)
            {
                stopwatch.Restart();

                if (iteration != 0)
                {
                    universe = EvolveUniverse(universe, options.Periodic, options.NeighbourOrder, options.NeighbourhoodType, options.CentreCount, options.BirthRate, options.SurvivalRate);
                }

                if (universeList.Count == options.GenerationalMemory) //Remove the first item in the list if the list capacity is reached (Capacity is the generationalMemory)
                {
                    universeList.RemoveAt(0);
                }

                UpdateGrid(grid, universe);

                grid.SetFootnote($"Generation: {iteration++}");
                grid.Render();
                isSteadyState = CheckSteadyState(universeList, options, universe); //Check if the current universe have reached a steady state
                if (isSteadyState)
                {
                    break; //If a steady state is found then stop the next generation from happening
                }
                universeList.Add(universe);

                if (options.StepMode)
                {
                    WaitSpacebar();
                }
                else
                {
                    while (stopwatch.ElapsedMilliseconds < 1000 / options.UpdateRate)
                    {
                        ;
                    }
                }
            }

            grid.IsComplete = true;
            grid.Render();

            if (!string.IsNullOrEmpty(options.OutputFile))
            {
                using StreamWriter writer = new StreamWriter(options.OutputFile);
                writer.WriteLine("#version=2.0");
                OutputToFile(options, universeList, writer);
                writer.Close();
                successfullyWroteToFile = true;
            }
            WaitSpacebar();

            grid.RevertWindow();


            if (isSteadyState && options.IsAllDead == false)
            {
                Logging.Message($"Steady-state detected... periodicity = {iteration - 1}");
            }
            if (isSteadyState && options.IsAllDead == true)
            {
                Logging.Message($"Steady-state detected... periodicity = N/A");
            }
            if (successfullyWroteToFile)
            {
                Logging.Success($": Final generation written to file: {options.OutputFile}");
            }
            Logging.Message("Press spacebar to exit program...");
            WaitSpacebar();
        }
Пример #4
0
        /// <summary >
        /// Starts the simulation by running the main loop of the program
        /// This method calls other methods to collect the information required to use the Display API.
        /// </ summary >
        /// <param name =" grid " > Used to display the Cell matrix in the console </ param >
        public int start(Grid grid)
        {
            Stopwatch watch = new Stopwatch();                                              //initialise time

            CellState[,] state = new CellState[getRows, getColumns];                        //set state for each cell
            CellState[] ghostState = { CellState.Dark, CellState.Medium, CellState.Light }; //ghost states

            for (int g = 0; g <= getGenerations; g++)                                       //loop per generation
            {
                watch.Restart();

                for (int r = 0; r < getRows; r++) // For each of the cells...
                {
                    for (int c = 0; c < getColumns; c++)
                    {
                        state[r, c] = CellState.Blank;                                                    //clear cell state

                        int ghosts = (previousGenerations.Count > 2) ? 2 : previousGenerations.Count - 1; //ghost count

                        ghosts = (ghostMode) ? ghosts : -1;                                               //turn on : off ghost mode

                        for (int gh = ghosts; gh >= 0; gh--)
                        {
                            state[r, c] = (previousGenerations[gh][r, c] == alive) ? ghostState[gh] : state[r, c]; //set ghosts
                        }

                        state[r, c] = (cells[r, c] == alive) ? CellState.Full : state[r, c]; //get new generation states

                        grid.UpdateCell(r, c, state[r, c]);                                  // Update grid
                    }
                }

                while (watch.ElapsedMilliseconds < (1 / getMaxUpdate * 1000))
                {
                    ;                                 //Timer
                }
                grid.SetFootnote("Generation: " + g); //prints current generation

                grid.Render();                        // Render updates to the console window...

                period = steadyState(cells);          //get period

                if (period > -1)                      //steady state? End game if true
                {
                    if (getOutputPath != String.Empty)
                    {
                        outputSeed(cells);                               //output seed
                    }
                    return(period);
                }

                cells = this.mutation(cells); //MUTATION, following the Conways game of life...

                if (stepMode)
                {
                    space();           //Step Mode
                }
            }

            if (getOutputPath != String.Empty)
            {
                outputSeed(cells);                                //output seed
            }
            return(period);
        }
        /// <summary>
        /// Main Function which contains all code that wasn't put into methods
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            // Declaring the variables
            int    Rows               = 16;    // Default: 16. Change as required for testing.
            int    Columns            = 16;    // Default: 16. Change as required for testing.
            bool   PeriodicBehaviour  = false; // Default: false. Change as required for testing
            double RandFactor         = 0.5;   // Default: 0.5. Change as required for testing
            string InputFile          = "";    // Default: NO input. Change as required for testing
            int    Generations        = 50;    // Default: 50. Change as required fo testing
            double MaxUpdateRate      = 5;     // Default: 5. Change as required for testing
            bool   StepMode           = false; // Default: NOT step mode. Change as required for testing
            bool   CheckAllConditions = true;  //Checking all the parameters

            //To count the number of generations
            int GenCount = 0;

            Stopwatch watch = new Stopwatch();


            // Checking the user input
            for (int count = 0; count < args.Length; count++)
            {
                //Checking the dimensions of the game
                CheckDimensions(ref args, ref count, ref Rows, ref Columns, ref CheckAllConditions);

                //Checking if the game will have periodic behaviour
                CheckPeriodic(ref args, ref count, ref PeriodicBehaviour);

                //Checking Random factor
                CheckRandomFactor(ref args, ref count, ref RandFactor, ref CheckAllConditions);

                //Checking the input file
                CheckSeedfile(ref args, ref count, ref InputFile, ref CheckAllConditions);

                //Checking the generations
                GenerationMethod(ref args, ref count, ref Generations, ref CheckAllConditions);

                //Checking the max update rate
                MaxUpdaterate(ref args, ref count, ref MaxUpdateRate, ref CheckAllConditions);

                //Checking step mode
                StepModeMethod(ref args, ref count, ref StepMode);
            }

            //Game array which stores the cell coordinates
            int[,] GameArray = new int[Rows, Columns];

            //Temporary Array to store the neighbours
            int[,] TempArray = new int[Rows, Columns];

            // Construct grid...
            Grid grid = new Grid(Rows, Columns);


            //Checking randomness
            RandomnessMethod(ref InputFile, ref Columns, ref Rows, ref GameArray, ref RandFactor);

            //Displaying user uput
            DispUserInput(ref CheckAllConditions, ref InputFile, ref Generations, ref MaxUpdateRate, ref PeriodicBehaviour,
                          ref Rows, ref Columns, ref StepMode, ref RandFactor);

            // Wait for user to press a key...
            Console.WriteLine("Press any key to start...");
            Console.ReadKey();


            // Game
            // Initialize the grid window (this will resize the window and buffer
            grid.InitializeWindow();

            // Set the footnote (appears in the bottom left of the screen).
            grid.SetFootnote("Life " + GenCount);

            // Declaring variable to see if neighbouring cells are active for next generation
            int ThreeCount = 0;

            // For each of the cells...
            for (int i = 0; i < GameArray.GetLength(0); i++)
            {
                for (int j = 0; j < GameArray.GetLength(1); j++)
                {
                    if (GameArray[i, j] == 1)
                    {
                        // Update grid with a new cell...
                        grid.UpdateCell(i, j, CellState.Full);
                    }
                    else
                    {
                        grid.UpdateCell(i, j, CellState.Blank);
                    }
                }
            }

            // Timer for Life game
            watch.Restart();
            while (watch.ElapsedMilliseconds < (1000 / MaxUpdateRate))
            {
                ;
            }

            grid.Render();

            //Increasing the generations
            while (Generations >= GenCount)
            {
                //Checking the neighbours of the cells
                ActualGame(ref Rows, ref Columns, ref GameArray, ref ThreeCount, ref PeriodicBehaviour, ref TempArray);

                //Step function holding answer till space is pressed
                if (StepMode == true)
                {
                    while (Console.ReadKey().Key != ConsoleKey.Spacebar)
                    {
                        ;
                    }
                }
                grid.SetFootnote("Life " + GenCount);

                // For each of the cells...
                for (int i = 0; i < GameArray.GetLength(0); i++)
                {
                    for (int j = 0; j < GameArray.GetLength(1); j++)
                    {
                        if (TempArray[i, j] == 1)
                        {
                            // Update grid with a new cell...
                            grid.UpdateCell(i, j, CellState.Full);
                            GameArray[i, j] = TempArray[i, j];
                        }
                        else
                        {
                            grid.UpdateCell(i, j, CellState.Blank);
                            GameArray[i, j] = 0;
                        }
                        TempArray[i, j] = 0;
                    }
                }

                // Timer for Life Game
                watch.Restart();
                while (watch.ElapsedMilliseconds < (1000 / MaxUpdateRate))
                {
                    ;
                }
                // Render updates to the console window...
                grid.Render();
                GenCount++;
            }

            // Set complete marker as true
            grid.IsComplete = true;

            grid.Render();

            Console.ReadKey();

            grid.RevertWindow();
        }