KeiroKamioka

GameOfLife

Apr 20th, 2021
1,056
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using static System.Console;
  3. using System.Threading;
  4. //using Nlog;    
  5.  
  6. namespace GameOfLife
  7. {
  8.     class Program
  9.     {
  10.         const int Dead = 0;             // Using a grid of 0's and 1's will help us count
  11.         const int Alive = 1;            //   count neighbors efficiently in the Life program.
  12.  
  13.         static int GridSizeX = 25;
  14.         static int GridSizeY = 25;
  15.  
  16.  
  17.         static void Main(string[] args)
  18.         {
  19.             WriteLine("Conway's Game of Life:");
  20.             WriteLine("=====================================================");
  21.             int gridCount = 0;
  22.             int[,] grid = new int[GridSizeX, GridSizeY];
  23.  
  24.             bool isSilentMode = false;
  25.             bool isRMode = false;
  26.             if (args.Length > 0)
  27.             {
  28.                 if (args[0].ToLower() == "silent")
  29.                 {
  30.                     isSilentMode = true;
  31.                     WriteLine("Silent Mode");
  32.                 }
  33.             }
  34.             if (args.Length > 1)
  35.             {
  36.                 if (args[1].ToLower() == "r")
  37.                 {
  38.                     isRMode = true;
  39.                     rGen(grid);
  40.                     WriteLine("Starting with R-Pentonimo");
  41.                    
  42.                 }
  43.             }
  44.  
  45.             bool done = false;
  46.  
  47.             //Show Default Grid if not r mode enable
  48.  
  49.             if (isRMode == false)
  50.             {
  51.                 defaultGen(grid);
  52.             }
  53.            
  54.  
  55.             while (!done)
  56.             {
  57.                 // Clear Previous Console
  58.                 Console.Clear();
  59.  
  60.                 // Display the grid (and its statistics)
  61.                 WriteLine($"Grid #{gridCount}");
  62.                 PrintGrid(grid);
  63.                 WriteLine($"Grid #{gridCount}  aliveCount: {CountLiveCells(grid)}");
  64.  
  65.                 Thread.Sleep(500);
  66.  
  67.                 // Check to see if the user pressed a key
  68.                 if (Console.KeyAvailable)
  69.                 {
  70.                     ConsoleKey key = Console.ReadKey(true).Key;
  71.                     if (key == ConsoleKey.Q)
  72.                         done = true;
  73.                 }
  74.  
  75.                 // Randomly Fill the Grid
  76.                 CalcNextGen(grid);
  77.  
  78.                 gridCount++;            // Increment at bottom of loop so that first grid displayed is Grid #0
  79.             }
  80.         }
  81.  
  82.         static void FillGridRandomly(int[,] grid, int fillPercentage)
  83.         {
  84.             for (int x=0; x < GridSizeX; x++)
  85.             {
  86.                 for (int y=0; y < GridSizeY; y++)
  87.                 {
  88.                     if (RandomBool(fillPercentage) == true)
  89.                         grid[x,y] = Alive;
  90.                     else
  91.                         grid[x,y] = Dead;
  92.                 }
  93.             }
  94.         }
  95.  
  96.         static bool RandomBool(int percent)
  97.         {
  98.             Random rng = new Random();
  99.             return (rng.Next() % 100 < percent);
  100.         }
  101.  
  102.         static void PrintGrid(int[,] grid)
  103.         {
  104.             WriteLine($"+{Dashes(GridSizeX*3)}+");
  105.             for (int y=0; y < GridSizeY; y++)
  106.             {
  107.                 string s = "|";
  108.                 for (int x=0; x < GridSizeX; x++)
  109.                 {
  110.                     string cell = (grid[x,y] == Alive) ? " * " : "   ";
  111.                     s += cell;
  112.                 }
  113.                 s += "|";
  114.                 WriteLine(s);
  115.             }
  116.             WriteLine($"+{Dashes(GridSizeX*3)}+");
  117.         }
  118.  
  119.         static string Dashes(int number)
  120.         {
  121.             return new string('-', number);
  122.         }
  123.  
  124.         static int CountLiveCells(int[,] grid)
  125.         {
  126.             int count = 0;
  127.             for (int x=0; x < GridSizeX; x++)
  128.                 for (int y=0; y < GridSizeY; y++)
  129.                     if (grid[x,y] == Alive)
  130.                         count++;
  131.             return count;
  132.         }
  133.  
  134.         static void defaultGen(int[,] currentGrid)
  135.         {
  136.             currentGrid[13,13] = Alive;
  137.             currentGrid[13+1,13+1] = Alive;
  138.             currentGrid[13+1,13-1] = Alive;
  139.             currentGrid[13-1,13-1] = Alive;
  140.             currentGrid[13-1,13+1] = Alive;
  141.  
  142.         }
  143.  
  144.         static void rGen(int[,] currentGrid)
  145.         {
  146.             currentGrid[14, 12] = Alive;
  147.             currentGrid[13, 12] = Alive;
  148.             currentGrid[13, 13] = Alive;
  149.             currentGrid[12, 13] = Alive;
  150.             currentGrid[13, 14] = Alive;
  151.         }
  152.  
  153.         static void CalcNextGen(int[,] currentGrid)
  154.         {
  155.                 int[,] newGrid = new int[GridSizeX, GridSizeY];
  156.                 for (int y = 1; y < GridSizeY - 1; y++)
  157.                 {
  158.                     for (int x = 1; x < GridSizeX - 1; x++)
  159.                     {
  160.                         int numNeighbor =
  161.                         currentGrid[x - 1, y - 1] + currentGrid[x, y - 1] + currentGrid[x + 1, y - 1] +
  162.                         currentGrid[x - 1, y] + currentGrid[x + 1, y] +
  163.                         currentGrid[x - 1, y + 1] + currentGrid[x, y + 1] + currentGrid[x + 1, y + 1];
  164.  
  165.                         if (currentGrid[x, y] == Alive)
  166.                         {
  167.                             if (numNeighbor == 2 || numNeighbor == 3)
  168.                             {
  169.                                 newGrid[x, y] = Alive;
  170.                             }
  171.                             else
  172.                             {
  173.                                 newGrid[x, y] = Dead;
  174.                             }
  175.                         }
  176.                         else
  177.                         {
  178.                             if (numNeighbor == 3)
  179.                             {
  180.                                 newGrid[x, y] = Alive;
  181.                             }
  182.                             else
  183.                             {
  184.                                 newGrid[x, y] = Dead;
  185.                             }
  186.                         }
  187.                     }
  188.                 }
  189.            
  190.         }
  191.     }
  192.    
  193. }
  194.  
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×