Mines | C# Online Compiler

Mines by peperunii

using System;
using System.Threading;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;

namespace Rextester
{
    public static class Params
    {
        static public int gameFieldX = 10;
        static public int gameFieldY = 10;
        static public int numberOfMines = 50;
	static public Random rnd;

	static public bool firstMoveIsSafe = false;
	static public string failMessage = "BOOM! Wanna start a new game? (Y/N)";

	static Params()
	{
		rnd = new Random();
	}
    }
    
    public class Game
    {
        private List<Mine> mines;
        private Field field;
        int [,] fieldValues;
	int [,] fieldProcessed;
	int numberOfReveals;
	bool shouldRestartGameFirstMoveSafe;

	private Point2D cursorPos;
		
        public Game()
        {
	    this.cursorPos = new Point2D(1, 1);
            this.Start();
        }
        
        public void Start()
        {
            while(true)
            {
		/*Mines generation*/
            	GenerateMines();
		this.numberOfReveals = 0;
		
		this.fieldValues = new int[Params.gameFieldX, Params.gameFieldY];
		this.fieldProcessed = new int[Params.gameFieldX, Params.gameFieldY];
            	this.field = new Field();

		FillFieldProcessedArrWith0();
            	CalculateFieldNumbers();
		
                field.Draw();
                
		if(this.shouldRestartGameFirstMoveSafe)
		{
			Console.SetCursorPosition(this.cursorPos.x, this.cursorPos.y);
		}
		else
		{
			Console.SetCursorPosition(1, 1);
		}
		//PrintMines();
		//PrintSolution();	
                var gameResult = true;
                
                while(true)
                {
			if(this.shouldRestartGameFirstMoveSafe)
			{
				//Simulate SPACE key pressed
				this.shouldRestartGameFirstMoveSafe = false;
				SendKeys.SendWait(" ");
			}
			var userInput = Console.ReadKey(true).Key;
					
			var newX = this.cursorPos.x;
			var newY = this.cursorPos.y;
					
			switch(userInput)
			{
				case ConsoleKey.LeftArrow:
					if(newX - 2 > 0) newX -= 2;
					break;
						
				case ConsoleKey.RightArrow:
					if(newX + 2 < 2 * Params.gameFieldX + 1) newX += 2;
					break;
						
				case ConsoleKey.UpArrow:
					if(newY - 2 > 0) newY -= 2;
					break;
						
				case ConsoleKey.DownArrow:
					if(newY + 2 < 2 * Params.gameFieldY + 1) newY += 2;
					break;
						
				case ConsoleKey.Spacebar:
					gameResult = this.ClickAction(newX, newY);
					break;
						
				case ConsoleKey.M:
					this.MarkMineAction();
					break;
			}
					
			this.cursorPos = new Point2D(newX, newY);
			Console.SetCursorPosition(newX, newY);

			if(!gameResult)
			{
				break;
			}
					
			Thread.Sleep(10);
                }
                
		if(!this.shouldRestartGameFirstMoveSafe)
		{
                	Console.SetCursorPosition(0, 2 * Params.gameFieldY + 2);
                	Console.WriteLine(Params.failMessage);
                	var key = Console.ReadKey(true).Key;
                
                	if(key != ConsoleKey.Y) break;
		}
            }
        }
        
	private void FillFieldProcessedArrWith0()
	{
		Console.SetCursorPosition(0, Params.gameFieldY + 2);
		for(int i = 0; i < Params.gameFieldX; i++)
		{
			for(int j = 0; j  < Params.gameFieldY; j++)
			{
				this.fieldProcessed[j, i] = 0;
			}
		}
	}

	private void PrintMines()
	{
	    	Console.WriteLine("Mines");
	    	for(int i = 0; i < Params.numberOfMines; i++)
            	{
             	   Console.WriteLine("x: {0}, y:{1}", this.mines[i].location.x /2, this.mines[i].location.y /2);
            	}
	}

	private void PrintSolution()
	{
            	Console.WriteLine("Solution");
	    	for(int i = 0; i < Params.gameFieldX; i++)
		{
			for(int j = 0; j  < Params.gameFieldY; j++)
			{
                		Console.Write("{0}, ", this.fieldValues[i, j]);
            		}
			Console.Write("\n");
		}
	}

	private void CalculateFieldNumbers()
	{
		for(int i = 0; i < Params.gameFieldX; i++)
		{
			for(int j = 0; j  < Params.gameFieldY; j++)
			{
				/*fieldValues buffer is with reular grid size - defined in Params - 
				but mines and cursor position are in extended grid size*/
				this.fieldValues[j, i] = GetNumberOfNearbyMines(2 * j + 1, 2 * i + 1);
			}
		}
	}
		
	private int GetNumberOfNearbyMines(int x, int y)
	{
		int minesNumber = 0;
			
		foreach(var mine in this.mines)
		{
			var location = mine.location;
				
			/*check if it is a mine location*/
			if(x == location.x &&
			   y == location.y)
			{
				minesNumber = -1;
				break;
			}
			else
			{
				var mineFound = false;
				for(int k = location.x -2; k <= location.x + 2; k += 2)
				{
					for(int l = location.y - 2; l <= location.y + 2; l += 2)
					{
						if(k == x &&
			   			   l == y)
						{
							mineFound = true;
						}
					}
						
					if(mineFound) break;
				}
					
				if(mineFound)
				{
					minesNumber++;
				}
			}
		}
			
		return minesNumber;
	}
		
	private bool ClickAction(int posX, int posY, bool isClickedAuto = false)
	{
		var result = true;
			
		if(!isClickedAuto)
		{
			this.numberOfReveals++;
		}

		if(this.fieldProcessed[posX / 2, posY / 2] == 0)
		{
			this.fieldProcessed[posX / 2, posY / 2] = 1;

			
			/*Check if current position of the cursor is already opened 
			and if it is equal to a position of a mine*/
			
			Console.SetCursorPosition(posX, posY);
			
			if(this.fieldValues[posX / 2, posY / 2] == -1 && !isClickedAuto)
			{
                		Console.Write('x');
				
				if(this.numberOfReveals == 1)
				{
					this.shouldRestartGameFirstMoveSafe = true;
				}
				result = false;
			}
			else
			{
				var numMines = this.fieldValues[posX / 2, posY / 2];
				
				if(numMines > 0)
				{
                    			Console.Write(numMines);
				}
				else if(numMines == 0)
				{
					Console.Write('.');
					
					for(int i = posX - 2; i <= posX + 2; i += 2)
					{
						for(int j = posY - 2; j <= posY + 2; j += 2)
						{
							if(i > 0 && 
							   j > 0 && 
							   i <= 2 * Params.gameFieldX && 
							   j <= 2 * Params.gameFieldY)
							{
								this.ClickAction(i, j, true);
							}
						}
					}
				}
			}
		}
			
		return result;
	}
		
	private void MarkMineAction()
	{
		if(this.fieldProcessed[this.cursorPos.x / 2, this.cursorPos.y / 2] == 0)
		{
			this.fieldProcessed[this.cursorPos.x / 2, this.cursorPos.y / 2] = 1;
			
		}
	}
		
    	private void GenerateMines()
        {
            this.mines = new List<Mine>();
            for(int i = 0; i < Params.numberOfMines; i++)
            {
                this.mines.Add(new Mine(this.mines));
                //Console.WriteLine("x: {0}, y:{1}", this.mines[i].location.x, this.mines[i].location.y);
            }
        }
    }
    
    public class Field
    {
	public Field()
	{
	}
		
        public void Draw()
        {
            ClearField();
            
            DrawLines();
        }
        
        private void DrawLines()
        {
            var endYIndex = 2 * Params.gameFieldY + 1;
            var endXIndex = 2 * Params.gameFieldX + 1;
            
            for(int i = 0; i < endYIndex; i++)
            {
                if(i % 2 == 0)
                {
                    Console.SetCursorPosition(0, i);
                    
                    Console.WriteLine(GetStringRowLength('-'));
                }
                else
                {
                    for(int j = 0; j < endXIndex; j += 2)
                    {
                        Console.SetCursorPosition(j, i);
                    
                        Console.Write('|');
                    }
                }
            }
        }
        
        private void ClearField()
        {
            for(int i = 0; i < 2 * Params.gameFieldY + 3; i++)
            {
                Console.SetCursorPosition(0, i);
                Console.WriteLine(GetStringRowLength(' '));
            }
        }
        
        private string GetStringRowLength(char ch)
        {
	    var strBuilder = new StringBuilder();
			
            for(int j = 0; j < 2 * Params.gameFieldX; j++)
            {
                strBuilder.Append(ch);
            }
            
            return strBuilder.ToString();
        }
    }
    
    public class Point2D
    {
        public int x;
        public int y;
        
        public Point2D(int _x, int _y)
        {
            this.x = _x;
            this.y = _y;
        }
		
	public bool Equals(Point2D other)
	{
		return ((other.x == this.x) &&  (other.y == this.y));
	}
		
	public Point2D Clone()
	{
		return new Point2D(this.x, this.y);
	}
    }
    
    public class Mine
    {
        public Point2D location;
        
        public Mine(List<Mine> existingMines)
        {
            this.location = GetNewMineLocation(existingMines);
        }
        
        private Point2D GetNewMineLocation(List<Mine> existingMines)
        {
            var x = 0;
            var y = 0;
            
            while(true)
            {
                x = RandomNumberOdd(1, 2 * Params.gameFieldX);
                y = RandomNumberOdd(1, 2 * Params.gameFieldY);
                
                var uniqueResult = true;
                
                foreach(var mine in existingMines)
                {
                   if(mine.location.x == x &&
                      mine.location.y == y)
                   {
                       uniqueResult = false;
                       break;
                   }
                }
                
                if(uniqueResult) break;
            }
            
            return new Point2D(x, y);
        }
        
        private int RandomNumberOdd(int min, int max)
        {
            int ans = Params.rnd.Next(min, max);
            if (ans % 2 == 1) return ans;
            else
            {
                if (ans + 1 <= max)
                    return ans + 1;
                else if (ans - 1 >= min)
                    return ans - 1;
                else return 0;
            }
        }
    }
    
    public class Program
    {
        public static void Main(string[] args)
        {
            new Game();
        }
    }
}

​x
 
using System;
using System.Threading;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Windows.Forms;
​
namespace Rextester
{
    public static class Params
    {
        static public int gameFieldX = 10;
        static public int gameFieldY = 10;
        static public int numberOfMines = 50;
    static public Random rnd;
​
    static public bool firstMoveIsSafe = false;
    static public string failMessage = "BOOM! Wanna start a new game? (Y/N)";
​
    static Params()
    {
        rnd = new Random();
    }
    }
    
    public class Game
    {
        private List<Mine> mines;
        private Field field;
        int [,] fieldValues;
    int [,] fieldProcessed;
    int numberOfReveals;
    bool shouldRestartGameFirstMoveSafe;
​
    private Point2D cursorPos;
        
        public Game()
        {
        this.cursorPos = new Point2D(1, 1);
            this.Start();
        }
        
        public void Start()
        {
            while(true)
            {
        /*Mines generation*/
                GenerateMines();
        this.numberOfReveals = 0;
        
        this.fieldValues = new int[Params.gameFieldX, Params.gameFieldY];
        this.fieldProcessed = new int[Params.gameFieldX, Params.gameFieldY];
                this.field = new Field();
​
        FillFieldProcessedArrWith0();
                CalculateFieldNumbers();
        
                field.Draw();
                
        if(this.shouldRestartGameFirstMoveSafe)
        {
            Console.SetCursorPosition(this.cursorPos.x, this.cursorPos.y);
        }
        else
        {
            Console.SetCursorPosition(1, 1);
        }
        //PrintMines();
        //PrintSolution();  
                var gameResult = true;
                
                while(true)
                {
            if(this.shouldRestartGameFirstMoveSafe)
            {
                //Simulate SPACE key pressed
                this.shouldRestartGameFirstMoveSafe = false;
                SendKeys.SendWait(" ");
            }
            var userInput = Console.ReadKey(true).Key;
                    
            var newX = this.cursorPos.x;
            var newY = this.cursorPos.y;
                    
            switch(userInput)
            {
                case ConsoleKey.LeftArrow:
                    if(newX - 2 > 0) newX -= 2;
                    break;
                        
                case ConsoleKey.RightArrow:
                    if(newX + 2 < 2 * Params.gameFieldX + 1) newX += 2;
                    break;
                        
                case ConsoleKey.UpArrow:
                    if(newY - 2 > 0) newY -= 2;
                    break;
                        
                case ConsoleKey.DownArrow:
                    if(newY + 2 < 2 * Params.gameFieldY + 1) newY += 2;
                    break;
                        
                case ConsoleKey.Spacebar:
                    gameResult = this.ClickAction(newX, newY);
                    break;
                        
                case ConsoleKey.M:
                    this.MarkMineAction();
                    break;
            }
                    
            this.cursorPos = new Point2D(newX, newY);
            Console.SetCursorPosition(newX, newY);
​
            if(!gameResult)
            {
                break;
            }
                    
            Thread.Sleep(10);
                }
                
        if(!this.shouldRestartGameFirstMoveSafe)
        {
                    Console.SetCursorPosition(0, 2 * Params.gameFieldY + 2);
                    Console.WriteLine(Params.failMessage);
                    var key = Console.ReadKey(true).Key;
                
                    if(key != ConsoleKey.Y) break;
        }
            }
        }
        
    private void FillFieldProcessedArrWith0()
    {
        Console.SetCursorPosition(0, Params.gameFieldY + 2);
        for(int i = 0; i < Params.gameFieldX; i++)
        {
            for(int j = 0; j  < Params.gameFieldY; j++)
            {
                this.fieldProcessed[j, i] = 0;
            }
        }
    }
​
    private void PrintMines()
    {
            Console.WriteLine("Mines");
            for(int i = 0; i < Params.numberOfMines; i++)
                {
                   Console.WriteLine("x: {0}, y:{1}", this.mines[i].location.x /2, this.mines[i].location.y /2);
                }
    }
​
    private void PrintSolution()
    {
                Console.WriteLine("Solution");
            for(int i = 0; i < Params.gameFieldX; i++)
        {
            for(int j = 0; j  < Params.gameFieldY; j++)
            {
                        Console.Write("{0}, ", this.fieldValues[i, j]);
                    }
            Console.Write("\n");
        }
    }
​
    private void CalculateFieldNumbers()
    {
        for(int i = 0; i < Params.gameFieldX; i++)
        {
            for(int j = 0; j  < Params.gameFieldY; j++)
            {
                /*fieldValues buffer is with reular grid size - defined in Params - 
                but mines and cursor position are in extended grid size*/
                this.fieldValues[j, i] = GetNumberOfNearbyMines(2 * j + 1, 2 * i + 1);
            }
        }
    }
        
    private int GetNumberOfNearbyMines(int x, int y)
    {
        int minesNumber = 0;
            
        foreach(var mine in this.mines)
        {
            var location = mine.location;
                
            /*check if it is a mine location*/
            if(x == location.x &&
               y == location.y)
            {
                minesNumber = -1;
                break;
            }
            else
            {
                var mineFound = false;
                for(int k = location.x -2; k <= location.x + 2; k += 2)
                {
                    for(int l = location.y - 2; l <= location.y + 2; l += 2)
                    {
                        if(k == x &&
                           l == y)
                        {
                            mineFound = true;
                        }
                    }
                        
                    if(mineFound) break;
                }
                    
                if(mineFound)
                {
                    minesNumber++;
                }
            }
        }
            
        return minesNumber;
    }
        
    private bool ClickAction(int posX, int posY, bool isClickedAuto = false)
    {
        var result = true;
            
        if(!isClickedAuto)
        {
            this.numberOfReveals++;
        }
​
        if(this.fieldProcessed[posX / 2, posY / 2] == 0)
        {
            this.fieldProcessed[posX / 2, posY / 2] = 1;
​
            
            /*Check if current position of the cursor is already opened 
            and if it is equal to a position of a mine*/
            
            Console.SetCursorPosition(posX, posY);
            
            if(this.fieldValues[posX / 2, posY / 2] == -1 && !isClickedAuto)
            {
                        Console.Write('x');
                
                if(this.numberOfReveals == 1)
                {
                    this.shouldRestartGameFirstMoveSafe = true;
                }
                result = false;
            }
            else
            {
                var numMines = this.fieldValues[posX / 2, posY / 2];
                
                if(numMines > 0)
                {
                                Console.Write(numMines);
                }
                else if(numMines == 0)
                {
                    Console.Write('.');
                    
                    for(int i = posX - 2; i <= posX + 2; i += 2)
                    {
                        for(int j = posY - 2; j <= posY + 2; j += 2)
                        {
                            if(i > 0 && 
                               j > 0 && 
                               i <= 2 * Params.gameFieldX && 
                               j <= 2 * Params.gameFieldY)
                            {
                                this.ClickAction(i, j, true);
                            }
                        }
                    }
                }
            }
        }
            
        return result;
    }
        
    private void MarkMineAction()
    {
        if(this.fieldProcessed[this.cursorPos.x / 2, this.cursorPos.y / 2] == 0)
        {
            this.fieldProcessed[this.cursorPos.x / 2, this.cursorPos.y / 2] = 1;
            
        }
    }
        
        private void GenerateMines()
        {
            this.mines = new List<Mine>();
            for(int i = 0; i < Params.numberOfMines; i++)
            {
                this.mines.Add(new Mine(this.mines));
                //Console.WriteLine("x: {0}, y:{1}", this.mines[i].location.x, this.mines[i].location.y);
            }
        }
    }
    
    public class Field
    {
    public Field()
    {
    }
        
        public void Draw()
        {
            ClearField();
            
            DrawLines();
        }
        
        private void DrawLines()
        {
            var endYIndex = 2 * Params.gameFieldY + 1;
            var endXIndex = 2 * Params.gameFieldX + 1;
            
            for(int i = 0; i < endYIndex; i++)
            {
                if(i % 2 == 0)
                {
                    Console.SetCursorPosition(0, i);
                    
                    Console.WriteLine(GetStringRowLength('-'));
                }
                else
                {
                    for(int j = 0; j < endXIndex; j += 2)
                    {
                        Console.SetCursorPosition(j, i);
                    
                        Console.Write('|');
                    }
                }
            }
        }
        
        private void ClearField()
        {
            for(int i = 0; i < 2 * Params.gameFieldY + 3; i++)
            {
                Console.SetCursorPosition(0, i);
                Console.WriteLine(GetStringRowLength(' '));
            }
        }
        
        private string GetStringRowLength(char ch)
        {
        var strBuilder = new StringBuilder();
            
            for(int j = 0; j < 2 * Params.gameFieldX; j++)
            {
                strBuilder.Append(ch);
            }
            
            return strBuilder.ToString();
        }
    }
    
    public class Point2D
    {
        public int x;
        public int y;
        
        public Point2D(int _x, int _y)
        {
            this.x = _x;
            this.y = _y;
        }
        
    public bool Equals(Point2D other)
    {
        return ((other.x == this.x) &&  (other.y == this.y));
    }
        
    public Point2D Clone()
    {
        return new Point2D(this.x, this.y);
    }
    }
    
    public class Mine
    {
        public Point2D location;
        
        public Mine(List<Mine> existingMines)
        {
            this.location = GetNewMineLocation(existingMines);
        }
        
        private Point2D GetNewMineLocation(List<Mine> existingMines)
        {
            var x = 0;
            var y = 0;
            
            while(true)
            {
                x = RandomNumberOdd(1, 2 * Params.gameFieldX);
                y = RandomNumberOdd(1, 2 * Params.gameFieldY);
                
                var uniqueResult = true;
                
                foreach(var mine in existingMines)
                {
                   if(mine.location.x == x &&
                      mine.location.y == y)
                   {
                       uniqueResult = false;
                       break;
                   }
                }
                
                if(uniqueResult) break;
            }
            
            return new Point2D(x, y);
        }
        
        private int RandomNumberOdd(int min, int max)
        {
            int ans = Params.rnd.Next(min, max);
            if (ans % 2 == 1) return ans;
            else
            {
                if (ans + 1 <= max)
                    return ans + 1;
                else if (ans - 1 >= min)
                    return ans - 1;
                else return 0;
            }
        }
    }
    
    public class Program
    {
        public static void Main(string[] args)
        {
            new Game();
        }
    }
}

View IL Code