连连看

   java不易开发大型游戏,但任一语言都有是相通,本程序运行有些小问题,仅供参考:

package cn;
import java.util.*;
import java.lang.*;

//定义一个连线类
class LinkLine 
{
	//保存连接点
	private int[] points;
	//接收地图
	private int[][] blocks;

	public LinkLine(int[][] blocks)
	{
		this.blocks = blocks;
	}
	
	//判断两个点是否能连接成线段
	public boolean linkSegment(int x1 , int y1 , int x2 , int y2)
	{

		//如果在同一条垂直线上
		if(x1 == x2)	
		{
			if(y1 > y2)
			{
				int temp = y1;
				y1 = y2;
				y2 = temp;
			}
			for(int y = y1 ; y <= y2 ; y++)
			{
				//如果有障碍物
				if(blocks[y][x1] > 0)
				{
					return false;
				}


			}
			return true;
		}
		//如果在同一个水平线上
		else if(y1 == y2)
		{
			if(x1 > x2)
			{
				int temp = x1;
				x1 = x2;
				x2 = temp;
			}
			for(int x = x1 ; x <= x2 ; x++)
			{
				//如果有障碍物
				if(blocks[y1][x] > 0)
				{
					return false;
				}
			}
			return true;
		}

		return false;
	}
	//是否可以连接成符合游戏规则的折线
	public boolean foldLineAble(int x1 , int y1 , int x2 , int y2)
	{
		//每次都清空折点
		points = null;
		int minDistance = 0;

		for(int x = x1 - 1; x >= 0; x--)	//向左历遍
		{
			//如果第一条线段可以连接
			if(linkSegment(x1 , y1 , x , y1)) 
			{	
				//如果剩下两条也可以连接
				if(linkSegment(x , y1 , x , y2) &&
					linkSegment(x , y2 , x2 , y2))
				{	
					//计算最小路程
					minDistance = Math.abs(x1 - x) + 
						Math.abs(y2 - y1) + Math.abs(x2 - x);
					
					//保存折点
					points = new int[]{x1 , y1 , x , y1 , 
						x , y2 , x2 , y2};
					//找到折线,不再往这个方向搜索
					break;
				}
			}
			else
			{	//遇到障碍,不再往这个方向搜索
				break;
			}
		}

		for(int x = x1 + 1; x < blocks[0].length; x++)	//向右历遍
		{
			//如果第一条线段可以连接
			if(linkSegment(x1 , y1 , x , y1)) 
			{	
				//如果剩下两条也可以连接
				if(linkSegment(x , y1 , x , y2) &&
					linkSegment(x , y2 , x2 , y2))
				{	
					//计算最小路程
					int temp = Math.abs(x1 - x) + 
						Math.abs(y2 - y1) + Math.abs(x2 - x);
					
					//如果小于上次一历遍的路程或上一次历遍没有连接
					if(temp < minDistance || minDistance == 0)
					{
						minDistance = temp;
						//保存折点
						points = new int[]{x1 , y1 , x , y1 , 
							x , y2 , x2 , y2};	
					}
					
					//找到折线,不再在这个方向搜索
					break;
				}
			}
			else
			{
				break;
			}
		}

		for(int y = y1 + 1; y < blocks.length; y++)	//向下历遍
		{
			//如果第一条线段可以连接
			if(linkSegment(x1 , y1 , x1 , y)) 
			{	
				//如果剩下两条也可以连接
				if (linkSegment(x1 , y , x2 , y) && 
					linkSegment(x2 , y , x2 , y2))
				{
					//计算最小路程
					int temp = Math.abs(y - y1) + 
						Math.abs(x2 - x1) + Math.abs(y- y2);
					
					if(temp < minDistance || minDistance == 0)
					{
						minDistance = temp;
						//保存折点
						points = new int[]{x1 , y1 , x1 , y , 
							x2 , y , x2 , y2};
					}
					break;
				}
			}
			else
			{
				break;
			}
		}

		for(int y = y1 - 1; y >= 0; y--)	//向上历遍
		{
			//如果第一条线段可以连接
			if(linkSegment(x1 , y1 , x1 , y)) 
			{	
				//如果剩下两条也可以连接
				if (linkSegment(x1 , y , x2 , y) && 
					linkSegment(x2 , y , x2 , y2))
				{
					//计算最小路程
					int temp = Math.abs(y - y1) + 
						Math.abs(x2 - x1) + Math.abs(y- y2);
					
					if(temp < minDistance || minDistance ==0)
					{
						minDistance = temp;
						//保存折点
						points = new int[]{x1 , y1 , x1 , y ,
							x2 , y , x2 , y2};
					}
					break;
				}
			}
			else
			{
				break;
			}
		}

		if(points != null)
		{
			return true;
		}
		
		return false;
	}
	public boolean linkAble(int x1 , int y1 , int x2 , int y2)
	{
		boolean result = false;
		
		//如果是同一个点
		if(x1 == x2 && y1 == y2)
		{
			return false;
		}

		if(blocks[y1][x1] == blocks[y2][x2])
		{	
			/*
				先把要判断连接的两个点在地图的值置0,避免下面的
				检测把它们当成障碍物
			*/
			int temp1 = blocks[y1][x1];
			int temp2 = blocks[y2][x2];
			blocks[y1][x1] = 0;
			blocks[y2][x2] = 0;
			//先判断是否可以连接成线段
			result = linkSegment(x1 , y1 , x2 ,y2);
			
			if(result)
			{	//保存连接点
				points = new int[]{x1 , y1 , x2 ,y2};
			}
			else
			{
				//是否可以连成折线
				result = foldLineAble(x1 , y1 , x2 ,y2);
			}
			blocks[y1][x1] = temp1;
			blocks[y2][x2] = temp2;
		}
			
		return result;
	}

	//获取连接点
	public int[] getPoints()
	{
		return points;
	}
}

package cn;
import javax.swing.*;
import java.io.*;
import java.awt.event.*;
import java.awt.*;
import javax.imageio.*;
import java.util.*;
public class LinkGame
{
	//定义桌面大小
	private final int TABLE_WIDTH = 500;
	private final int TABLE_HEIGHT = 500;
	
	//定义一个10行10列的地图数组
	private final int ROW = 10;
	private final int COL = 10;
	
	private int[][] blocks = new int[ROW][COL];
	//保存地图块数,初始为36
	private int blockCounts = 100;
	//每块的障碍物的大小
	private final int BLOCK_SIZE = 50;

	//障碍物图形有9种
	private final int BLOCK_NUM = 8;
	//保存障碍无图片
	private Image[] blockImage = new Image[BLOCK_NUM+1];
	private Image backGroup;
	private Image selected ;
	
	//保存第一次选中的障碍物的数组坐标
	private int fristRow = -1;
	private int fristCol = -1;
	private int secondRow = -1;
	private int secondCol = -1;
	
	//选中的障碍物的个数
	private int selectCount = 0;
	private Random rand = new Random();
	
	private JFrame f = new JFrame("疯狂的猴子I——连连看");
	private Menu game = new Menu("游戏选项");
	private MenuItem start = new MenuItem("开始");
	private MenuBar mb = new MenuBar();
	private MyTable myTable = new MyTable();
	
	//定义一个连线类
	private LinkLine lkLine = new LinkLine(blocks);
	//是否可以连线
	private boolean isLinked = false;
	//用于接收折点
	private int[] points;
	
	//初始画地图
	public void initMap()throws Exception
	{
		backGroup = ImageIO.read(new File("image/back3.jpg"));
		selected = ImageIO.read(new File("image/selected.gif"));
		//获取障碍物图片
		for(int i = 1; i < BLOCK_NUM+1; i++)
		{
			try
			{
				blockImage[i] =  ImageIO.read(new File("image/"+i+".jpg"));
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			
		}
		/*
			初始化障碍物数组,将图片引索值依次赋给数组元素,
			保证所有类型的图片数都是偶数;最外层元素全都为0,
			因此不用赋值,数组模型如下:
					0 0 0 0 0 0 0 0 
					0 1 7 3 4 5 6 0 
					0 7 8 6 1 2 3 0  
					0 4 5 6 7 8 4 0 
					0 1 2 3 4 5 2 0  
					0 7 8 6 5 7 3 0  
					0 8 5 2 7 8 8 0 
					0 0 0 0 0 0 0 0 
		*/
		int index = 1;
		for(int i = 1; i < ROW-1; i++)
		{
			for(int j = 1; j < COL-1; j++)
			{
				blocks[i][j] = index;
				index++;
				//如果引索值超过图片的种类则重置引索
				if(index > BLOCK_NUM)
				{
					index = 1;
				}
			}
		}
		//随机打乱数组的排列20次
		for(int k = 0; k < 20; k++)
		{	
			for(int i = 1; i < ROW-1; i++)
			{
				for(int j = 1; j < COL-1; j++)
				{
					//随机生成行号
					int tempRow = rand.nextInt(ROW-2) + 1;

					//随机生成列号
					int tempCol = rand.nextInt(COL-2) + 1;

					//如果不是同一个元素,则交换两个元素
					if(tempRow != i || tempCol != j)
					{	
						int temp = blocks[tempRow][tempCol];
						blocks[tempRow][tempCol] = blocks[i][j];
						blocks[i][j] = temp;
					}
				}
			}
		}
		myTable.repaint();
	}

	//初始化组件
	public void initComponent()
	{
		//“开始”监听事件
		start.addActionListener(new ActionListener()
		{
			public void actionPerformed(ActionEvent event)
			{
				try
				{
					initMap();	
				}
				catch (Exception e)
				{
					System.out.println(e.getMessage());
				}
				
			}
		});

		game.add(start);
		mb.add(game);
		f.setMenuBar(mb);
		f.add(myTable);
		myTable.setPreferredSize(
			new Dimension(TABLE_WIDTH,TABLE_HEIGHT));
		f.pack();
		f.setVisible(true);

	}

	public void init()
	{
		//游戏桌面鼠标按下事件
		myTable.addMouseListener(new MouseAdapter()
		{
			public void mousePressed(MouseEvent e)
			{
				//将桌面坐标转换为数组坐标
				int xPos = e.getX() / BLOCK_SIZE;
				int yPos = e.getY() / BLOCK_SIZE;
				//如果超出地图范围,直接退出方法
				if(xPos < 1 || xPos > COL-2 || yPos < 1 ||
					yPos > ROW-2)
				{
					return;
				}

				selectCount ++;
				switch(selectCount)
				{
					case 1: //第一次选中
						fristRow = yPos;
						fristCol = xPos;
						break;
					case 2: //第二次选中
						secondRow = yPos;
						secondCol = xPos;
						break;
					default :
						break;
				}

				if(selectCount == 2)
				{
					//判断选中的障碍物是否可以连线
					isLinked = lkLine.linkAble(fristCol , fristRow , 
						secondCol , secondRow);
					//System.out.println(isLinked);
					//如果连线成功
					if(isLinked)
					{
						//清楚障碍物
						blocks[fristRow][fristCol] = 0;
						blocks[secondRow][secondCol] = 0;
						//获取折点
						points = lkLine.getPoints();
					}
				}
				myTable.repaint();
				
			}

			//游戏桌面鼠标松开事件
			public void mouseReleased(MouseEvent e)
			{
				//重置
				if(selectCount == 2)
				{
					selectCount=0;
				}
				
				myTable.repaint();
			}
			
		});
	}
	public static void main(String[] args)throws Exception
	{
		LinkGame lg = new LinkGame();
		//初始化地图
		lg.initMap();
		//初始化组件
		lg.initComponent();
		//初始游戏
		lg.init();
		
	}

	public void drawSelected(Graphics g)
	{
		int fristX ;
		int fristY ;
		int secondX ;
		int secondY ;

		//第一次选中或第2次选种
		if(selectCount == 1 || selectCount == 2)
		{
			g.drawImage(selected , fristCol*BLOCK_SIZE ,
				fristRow*BLOCK_SIZE , BLOCK_SIZE , 
				BLOCK_SIZE , null);
		}
		//第2次选种
		if(selectCount == 2)
		{
			g.drawImage(selected , secondCol * BLOCK_SIZE ,
				secondRow * BLOCK_SIZE , BLOCK_SIZE ,
				BLOCK_SIZE ,null);
			//如果连接成功
			if(isLinked)
			{
				//如果连接点为空直接返回
				if(points == null){return ;};
				
				//绘制连接线
				int index = 0;
				fristX = points[index++] ;
				fristY = points[index++] ;
				
				for(int i = index; i < points.length;)
				{	
					secondX = fristX ;
					secondY = fristY ;

					fristX = points[i++] ;
					fristY = points[i++] ;
					
					g.drawLine(
						fristX*BLOCK_SIZE + 25 ,
						fristY*BLOCK_SIZE + 25 , 
						secondX*BLOCK_SIZE + 25 ,
						secondY*BLOCK_SIZE + 25
						);	
				}
			}
		}
	}
	class MyTable extends JPanel
	{
		public void paint(Graphics g)
		{
			//背景
			g.drawImage(backGroup , 0 , 0 ,TABLE_WIDTH , 
				TABLE_HEIGHT ,null);
			//绘制障碍物
			for(int i = 0; i < ROW; i++)
			{
				for(int j = 0; j < COL; j++)
				{
					//是否有障碍物
					if(blocks[i][j] != 0)
					{
						int index = blocks[i][j];
						g.drawImage(
							blockImage[index] , 
							j*BLOCK_SIZE , 
							i*BLOCK_SIZE ,
							BLOCK_SIZE , 
							BLOCK_SIZE , 
							null
							);

						//绘制每一块障碍物的边框
						g.drawRect(
							j*BLOCK_SIZE , 
							i*BLOCK_SIZE , 
							BLOCK_SIZE , 
							BLOCK_SIZE
							);
					}
				}
			}

			//绘制选中点的红框
			drawSelected(g);
		}
	}

}