/*
 * @(#)MineSweeper.java 1.0 02/01/22
 *
 * You can modify the template of this file in the
 * directory ..\JCreator\Templates\Template_2\Project_Name.java
 *
 * You can also create your own project template by making a new
 * folder in the directory ..\JCreator\Template\. Use the other
 * templates as examples.
 *
 */

import java.awt.*;
import java.applet.*;
import java.awt.event.*;
import java.awt.image.*;


public class MineSweeper extends Applet implements ActionListener, MouseListener, ItemListener
{
	
	static int minefield[][] = new int[50][50];
	static int Tiles[][] = new int[50][50];
	
	static Image pic = Toolkit.getDefaultToolkit().getImage("field.jpg");
	static Image pic1 = Toolkit.getDefaultToolkit().getImage("field.jpg");
	static Image pic2 = Toolkit.getDefaultToolkit().getImage("mountain.jpg");
	static Image pic3 = Toolkit.getDefaultToolkit().getImage("explo.jpg");

	static int instance = 0;
	static int MinesOnField = 50;
	static int uncovered = MinesOnField;
	static int marked = 0;
	static int OffsetX = 25; 
	static int OffsetY = 50;
	static int SizeOfCol = 25;
	static int SizeOfRow = 25;
	int whichx, whichy;
	static int rows = 20;
	static int cols = 20;
	static int AppletWidth = 400;
	static int AppletHeight = 500;
	static int win = 0;
	static int TotalSize = rows*cols;
	static Choice difficulty = new Choice();
	static Button reload = new Button("Reload");
	Font font = new Font("Arial", Font.BOLD, 12);
	
	String info = "";
	
	
	
	
	public void CreateField()
	{
		
		int x, y, i = 0, hits = 0;
			while (i < MinesOnField)
			{
				x = (int)(Math.random()*cols);
				y = (int)(Math.random()*rows);
				if(	minefield[x][y] != -1)
				{
					minefield[x][y] = -1;
					i++;
				}
			} 
			for(x = 0; x < rows; x++)
				for(y = 0; y < cols; y++)
					{
						hits = 0;
						
							
						if(x+1 < cols && minefield[x+1][y] == -1)
							hits++;
						if(x-1 >= 0 &&  minefield[x-1][y] == -1)
							hits++;
						if(y+1 < rows && minefield[x][y+1] == -1)
							hits++;
						if(y-1 >= 0 && minefield[x][y-1] == -1)
							hits++;
						if(x+1 < cols && y+1 < rows && minefield[x+1][y+1] == -1)
							hits++;
						if(x+1 < cols && y-1 >= 0 && minefield[x+1][y-1] == -1)
							hits++;
						if(x-1 >= 0 &&  y+1 < rows && minefield[x-1][y+1] == -1)
							hits++;
						if(x-1 >= 0 &&  y-1 >= 0 && minefield[x-1][y-1] == -1)
							hits++;
							
							if(minefield[x][y] != -1)
								minefield[x][y] = hits;
					}
				
	}
	
	public void init() 
	{
			
			addMouseListener(this);
		setLayout(null);
		setSize(AppletWidth, AppletHeight);
		reload.setSize(50, 20);
		reload.setLocation(120, 0);
		add(reload);
		reload.addActionListener(this);
		difficulty.setSize(100, 10);
		add(difficulty);
		difficulty.addItemListener(this);
		difficulty.add("Easy");
		difficulty.add("Medium");
		difficulty.add("Hard");
		difficulty.add("Insane");
		ReInit(1);
	}
	
	public void ReInit(int state)
	{
		for(int x = 0; x < rows; x++)
			for(int y = 0; y < cols; y++)
			{
				Tiles[x][y] = 0;
				minefield[x][y] = 0;
			}
	
		CreateField();
		pic = pic1;
	switch(state)
	{
	 case 1:
		  MinesOnField = 10;
		  uncovered = 0;
		  marked = 0;
		  OffsetX = 10; 
		  OffsetY = 50;
		  rows = 15;
		  cols = 15;
		  SizeOfCol = (AppletWidth-OffsetX)/cols;
		  SizeOfRow = (AppletHeight-OffsetY)/rows;
		  win = 0;
		  TotalSize = rows*cols;
		  break;
	 case 2:
		  MinesOnField = 50;
		  uncovered = 0;
		  marked = 0;
		  OffsetX = 10; 
		  OffsetY = 50;
		  rows = 20;
		  cols = 20;
		  SizeOfCol = (AppletWidth-OffsetX)/cols;
		  SizeOfRow = (AppletHeight-OffsetY)/rows;
		  win = 0;
		  TotalSize = rows*cols;
		  break;
	 case 3:
		  MinesOnField = 200;
		  uncovered = 0;
		  marked = 0;
		  OffsetX = 10; 
		  OffsetY = 50;
		  rows = 25;
		  cols = 25;
		  SizeOfCol = (AppletWidth-OffsetX)/cols;
		  SizeOfRow = (AppletHeight-OffsetY)/rows;
		  win = 0;
		  TotalSize = rows*cols;
		  break;
	 case 4:
		  MinesOnField = 500;
		  uncovered = 0;
		  marked = 0;
		  OffsetX = 10; 
		  OffsetY = 50;
		  rows = 30;
		  cols = 30;
		  SizeOfCol = (AppletWidth-OffsetX)/cols;
		  SizeOfRow = (AppletHeight-OffsetY)/rows;
		  win = 0;
		  TotalSize = rows*cols;
		  break;
}
	  

		
	}
		
		

	public void paint(Graphics g)
	{
		
		g.drawImage(pic, 0, 0, this);
		g.setFont(font);
		setBackground(Color.lightGray);
	
		g.setColor(Color.black);
		g.drawString("Mines: " + MinesOnField, 200, 20);
		g.drawString("Cleared: " + uncovered, 200, 40);
		g.drawString("Marked: " + marked,300 , 20);
		g.drawString("Remaining: " + (MinesOnField-marked), 300, 40);
		if((TotalSize-(uncovered+marked)) == MinesOnField)
		{
			win = 2;
		pic = pic2;
				g.drawImage(pic, 0, 0, this);
				g.setColor(Color.yellow);
				g.setFont(new Font("Arial", Font.BOLD, 20));
				g.drawString("Field Clear!", 150, 320);

		}
			 
		
		for(int x = 0; x < rows; x++)
			for(int y = 0; y < cols; y++)
			{
				if(Tiles[x][y] == 2)
				{
					g.setColor(Color.red);
					g.drawLine((x*SizeOfCol)+OffsetX, y*SizeOfRow+OffsetY, (x*SizeOfCol)+SizeOfCol+OffsetX, (y*SizeOfRow)+SizeOfRow+OffsetY);
					g.drawLine((x*SizeOfCol)+OffsetX, (y*SizeOfRow)+SizeOfRow+OffsetY, (x*SizeOfCol)+SizeOfCol+OffsetX, (y*SizeOfRow+OffsetY));
				}
				if(Tiles[x][y] == 1)
				{
					if(win != 2)
					{
					g.setColor(Color.gray);
					g.fillRect((x*SizeOfCol)+OffsetX, (y*SizeOfRow)+OffsetY, SizeOfCol, SizeOfRow);		
					}
					
					
					switch(minefield[x][y])
					{
						case -1:
							g.setColor(Color.red);
							g.fillOval((x*SizeOfCol)+OffsetX, (y*SizeOfRow)+OffsetY, SizeOfCol, SizeOfRow);
							g.drawLine((x*SizeOfCol)+OffsetX, (y*SizeOfRow)+OffsetY, (x*SizeOfCol)+SizeOfCol+OffsetX, (y*SizeOfRow)+SizeOfRow+OffsetY);
							g.drawLine((x*SizeOfCol)+OffsetX, (y*SizeOfRow)+SizeOfRow+OffsetY, (x*SizeOfCol)+SizeOfCol+OffsetX, (y*SizeOfRow)+OffsetY);
							break;
						case -3:
							g.setColor(Color.black);
							g.fillOval((x*SizeOfCol)+OffsetX, (y*SizeOfRow)+OffsetY, SizeOfCol, SizeOfRow);
							g.drawLine((x*SizeOfCol)+OffsetX, (y*SizeOfRow)+OffsetY, (x*SizeOfCol)+SizeOfCol+OffsetX, (y*SizeOfRow)+SizeOfRow+OffsetY);
							g.drawLine((x*SizeOfCol)+OffsetX, (y*SizeOfRow)+SizeOfRow+OffsetY, (x*SizeOfCol)+SizeOfCol+OffsetX, (y*SizeOfRow)+OffsetY);
							break;
						case 1:
							g.setColor(Color.black);
							g.drawString(""+ minefield[x][y], x*SizeOfCol+2+OffsetX, (y*SizeOfRow)+SizeOfRow +OffsetY);
							break;
						case 2:
							g.setColor(Color.blue);
							g.drawString(""+ minefield[x][y], x*SizeOfCol+2+OffsetX, (y*SizeOfRow)+SizeOfRow +OffsetY);
							break;
						case 3:
							g.setColor(Color.green);
							g.drawString(""+ minefield[x][y], x*SizeOfCol+2+OffsetX, (y*SizeOfRow)+SizeOfRow +OffsetY);
							break;
						case 4:
							g.setColor(Color.yellow);
							g.drawString(""+ minefield[x][y], x*SizeOfCol+2+OffsetX, (y*SizeOfRow)+SizeOfRow +OffsetY);
							break;
						case 5:
							g.setColor(Color.orange);
							g.drawString(""+ minefield[x][y], x*SizeOfCol+2+OffsetX, (y*SizeOfRow)+SizeOfRow +OffsetY);
							break;
						case 6:
							g.setColor(Color.red);
							g.drawString(""+ minefield[x][y], x*SizeOfCol+2+OffsetX, (y*SizeOfRow)+SizeOfRow +OffsetY);
							break;
						case 7:
							g.setColor(Color.pink);
							g.drawString(""+ minefield[x][y], x*SizeOfCol+2+OffsetX, (y*SizeOfRow)+SizeOfRow+OffsetY );
							break;
						case 8:
							g.setColor(Color.magenta);
							g.drawString(""+ minefield[x][y], x*SizeOfCol+2+OffsetX, (y*SizeOfRow)+SizeOfRow+OffsetY );
							break;
					}
				}
				
			}
			if(win == 1)g.drawImage(pic, 0, 0, this);
				drawGrid(g);

	}
	public void drawGrid(Graphics g)
	{
		int x;
		g.setColor(Color.darkGray);
		for( x = 0; x <= rows; x++)				//horizontal lines
		g.drawLine(OffsetX, (x*SizeOfRow)+OffsetY, (SizeOfCol*cols)+OffsetX, (x*SizeOfRow)+OffsetY);
		for( x = 0; x <= cols; x++)
		g.drawLine((x*SizeOfCol)+OffsetX, OffsetY,  (x*SizeOfCol)+OffsetX, (SizeOfRow*cols)+OffsetY);
	}
		
	public void KillRegion(int x, int y)
	{
		if(x >= 0 && x < rows && y >=0 && y < cols)
		{
			if(Tiles[x][y] != 1)
			uncovered++;
			Tiles[x][y] = 1;
			
			if(minefield[x][y] == 0)
			{
				
				minefield[x][y] = -2;
			KillRegion(x+1, y);
			KillRegion(x-1, y);
			KillRegion(x, y+1);
			KillRegion(x, y-1);
			KillRegion(x+1, y+1);
			KillRegion(x-1, y+1);
			KillRegion(x+1, y-1);
			KillRegion(x-1, y-1);
		}
		}
			
		
	}
	public void ShowMines()
	{
		for(int x = 0; x < rows; x++)
			for(int y = 0; y < cols; y++)
			{
				if(minefield[x][y] == -1)
				{
					if(Tiles[x][y] == 2)
						minefield[x][y] = -3;
					Tiles[x][y] = 1;
				}
			}
			win = 2;
			repaint();
	}
		
	
	public void actionPerformed(ActionEvent evt)
	{
		
			ReInit(difficulty.getSelectedIndex()+1);
			repaint();
			
		
	}
	public void mouseClicked(MouseEvent evt)
	{
		if(evt.getModifiers() == evt.BUTTON1_MASK)
		{
			int x = ((evt.getX()-OffsetX)/SizeOfCol);
			int y = ((evt.getY()-OffsetY)/SizeOfRow);
			
			if(Tiles[x][y] == 2)
			marked--;
			if(minefield[x][y] == 0)
				KillRegion(x, y);
			else if (minefield[x][y] == -1)
			{
				pic = pic3;
				ShowMines();
			}
			else
			{
				Tiles[x][y] = 1;
				uncovered++;
			}
			
			repaint();
		
		}
		if(evt.getModifiers() == evt.BUTTON3_MASK)
		{
			int x = ((evt.getX()-OffsetX)/SizeOfCol);
			int y = ((evt.getY()-OffsetY)/SizeOfRow);
			
			if(Tiles[x][y] == 0)
			{
				Tiles[x][y] = 2;
				marked++;
				uncovered--;
				repaint();
			}
			else if(Tiles[x][y] == 2)
			{
				Tiles[x][y] = 0;
				uncovered++;
				marked--;
				repaint();
			}
			
		}
			
		
		
					
				
	}
	public void mousePressed(MouseEvent evt)
	{
	}
	public void mouseReleased(MouseEvent evt)
	{
	}
	public void mouseEntered(MouseEvent evt)
	{	
		
	}
	public void mouseExited(MouseEvent evt)
	{
	}
	public void itemStateChanged(ItemEvent evt)
	{
		int dif = difficulty.getSelectedIndex();
		switch(dif)
		{
			case 0:
				ReInit(1);
				break;
			case 1:
				ReInit(2);
				break;
			case 2:
				ReInit(3);
				break;
			case 3:
				ReInit(4);
				break;
		}
		repaint();
	}
		
}