model.java

java版的连连看游戏

	}

	/**
	 * @return 返回gamepanel行数
	 */
	public int getRows() {
		return rows;
	}

	/**
	 * @return 返回当前所点的图片
	 */
	public Point getSltMatrix() {
		return sltMatrix;
	}

	/**
	 * 水平的寻找，返回一个路径（包括这个路径上的所有的点）
	 * 
	 * @param p
	 *            原点
	 * @return 纵向空白点(包括与原点等值的点)
	 */
	private ArrayList<Point> getVSpaces(Point p, Point pg) {
		ArrayList<Point> ps = new ArrayList<Point>();
		// left
		for (int dif = 1;; dif++) {
			int col = p.y;
			int row = p.x - dif;
			// 向上走，如果左边的不为0且它与p2不相等，则下面if中的条件为真，退出，否则加进数祖
			if (row < 0
					|| (data[row][col] != 0 && !pg.equals(new Point(row, col))))
				break;
			ps.add(new Point(row, col));
		}
		// right
		for (int dif = 1;; dif++) {
			int col = p.y;
			int row = p.x + dif;
			// 向下走，如果左边的不为0且它与p2不相等，则下面if中的条件为真，退出，否则加进数祖
			if (row >= rows
					|| (data[row][col] != 0 && !pg.equals(new Point(row, col))))
				break;

			ps.add(new Point(row, col));
		}
		return ps;
	}

	/**
	 * 初始化数据
	 */
	private void initData() {
		data = new int[rows][cols];// 初始化data成0
		int sNums[] = null;
		sNums = numberSelector();

		int m, n, k = 0, k1, k2, k3;
		// 我们是这样初始化图片的,从42种图片中随机的选取70种数字对应的图片,然后每张图片用
		// 两次,一共是140张,把他们随机的放在data数组中,然后根据数组中的数据加载图片.
		for (m = 0; m < sNums.length; m++) {
			k1 = sNums[m];
			for (n = 1; n <= 2; n++) {
				k2 = (int) (Math.random() * 10 + 1);
				k3 = (int) (Math.random() * 14 + 3);
				while (data[k2][k3] != 0 && k != 140) {
					k2 = (int) (Math.random() * 10 + 1);
					k3 = (int) (Math.random() * 14 + 3);
				}
				this.data[k2][k3] = k1;
				k++;
			}
		}
		cardLeft = sNums.length * 2;// 初始化cardLeft
		historyRecord = LoadAndSave.getRecord();// 初始化历史纪录
	}

	/**
	 * 判断是否为空
	 * 
	 * @return boolean 图片为空的话就返回true，否则就返回false
	 */
	private boolean isEmpty(Point p) {
		return 0 == data[p.x][p.y];
	}

	/**
	 * 直线连
	 * 
	 * @param Point,Point
	 *            p1, p2前后所点的两个点
	 * @return boolean 返回一个boolean值说明直线是否可连
	 */
	private boolean noCorner(Point p1, Point p2) {
		// 只要getHSpaces(p1, p2).contains(p2)或者getVSpaces(p1,
		// p2).contains(p2)中有一个为真就说明可连
		return getHSpaces(p1, p2).contains(p2)
				|| getVSpaces(p1, p2).contains(p2);
	}

	/**
	 * 假如要连则自动调用Observer的update()方法，传参ArrayList<Point> points，里面存则着要连的信息
	 */
	private void notifyEffect(ArrayList<Point> points) {
		setChanged();
		notifyObservers(points);
	}

	/**
	 * 在min-max之间(包括min和max)随机选择count个数字序列
	 */
	private int[] numberSelector() {
		PICTURE_NUMBERS=getPictureNumber();
		int nums[] = new int[CARD_NUMBERS];
		ArrayList<Integer> list = new ArrayList<Integer>();
		for (int i = 1; i <= PICTURE_NUMBERS; i++) {
			list.add(i);
		}
		for (int i = 0; i < CARD_NUMBERS; i++) {
			nums[i] = list.get(new Random().nextInt(list.size()));
		}
		return nums;
	}

	/**
	 * 一个弯连
	 * 
	 * @param Point,Point
	 *            p1, p2前后所点的两个点
	 * @return boolean 返回一个boolean值说明直线是否可连
	 */
	private boolean oneCorner(Point p1, Point p2) {
		for (Point p : getHSpaces(p1, p2)) {
			// 固定行，上下遍历
			if (getVSpaces(p, p2).contains(p2)) {
				corner1 = p;
				return true;
			}
		}
		for (Point p : getVSpaces(p1, p2)) {
			// 固定列，左右遍历
			if (getHSpaces(p, p2).contains(p2)) {
				corner1 = p;
				return true;
			}
		}
		return false;
	}

	/**
	 * 专门用于随机打乱data中数据,即打乱图片的位置,用于在无解的时候刷新
	 */
	
	private void randomSort() {
		ArrayList<Integer> list = new ArrayList<Integer>();
		for (int row=0;row<rows;row++){
			for(int col=0;col<cols;col++){
				if(data[row][col]!=0)
					list.add(new Integer(data[row][col]));
			}
		}
		for (int row=0;row<rows;row++){
			for(int col=0;col<cols;col++){
				if(data[row][col]!=0)
				data[row][col]=list.remove(new Random().nextInt(list.size()));;
			}
		}
		/**ArrayList<Integer> list = new ArrayList<Integer>();
		for (int i = 1; i < data.length - 1; i++)
			for (int j = 3; j < data[0].length - 3; j++) {
				list.add(new Integer(data[i][j]));
			}
		for (int i = 1; i < data.length - 1; i++)
			for (int j = 3; j < data[0].length - 3; j++) {
				// 将删掉的那些随机的给data数组
				data[i][j] = list.remove(new Random().nextInt(list.size()));
			}
		sltMatrix = null;
		*/
	}

	/**
	 * 假如无解则自动调用Observer的update()方法，无参
	 */
	private void refresh() {
		randomSort();
		updateAll();
	}
	/**
	 * 重新开始游戏，重新初始化所有数据
	 */
	public void restartGame() {
		score=0;
	    level=1;
		count=0;
		timeLeft=350;
		pictureFile=getPictureFile();
		notifyRemind();
		initData();// 初始化数据
		synchronized (t) {
			t.notify();
			startTime = System.currentTimeMillis();// 得到开始时间
		}
		updateAll();
	}
	/**
	 * 游戏开始
	 */
	public void gameStart() {

		count = getCount();// 获取提示次数
		initCount=count;
		pictureFile=getPictureFile();
		switch(level){
		case 1: setPictureNumber(30);
		        setTimeLeft(350);
		        setScore(0);
		break;
		case 2: setPictureNumber(34);
		        setTimeLeft(400);
		        setScore(700);
		break;
		case 3: setPictureNumber(38);
		        setTimeLeft(450);
		        setScore(1400);
		break;
		case 4: setPictureNumber(42);
		        setTimeLeft(500);
		        setScore(2100);
		break;
		default :
			setPictureNumber(42);
        setTimeLeft(500);
        break;
		}
		if (count > 1)
			count = setCount(count - 2);
		else if(count==1)
			count=setCount(count-1);
		notifyRemind();
		initData();// 初始化数据
		synchronized (t) {
			t.notify();
			startTime = System.currentTimeMillis();// 得到开始时间
		}
		updateAll();
	}

	/**
	 * 设置当前所点的图片
	 * 
	 * @param sltMatrix
	 *            要去替换sltMatrix的点
	 */
	public void setSltMatrix(Point sltMatrix) {
		this.sltMatrix = sltMatrix;
	}

	/**
	 * 两个弯连
	 * 
	 * @param Point,Point
	 *            p1, p2前后所点的两个点
	 * @return boolean 返回一个boolean值说明直线是否可连
	 */
	private boolean twoCorner(Point p1, Point p2) {
		for (Point ph : getHSpaces(p1, p2)) {
			// 固定行，上下遍历
			for (Point pv : getVSpaces(ph, p2)) {
				// 再固定列，左右遍历
				if (getHSpaces(pv, p2).contains(p2)) {
					corner1 = ph;
					corner2 = pv;
					return true;
				}
			}
		}
		for (Point pv : getVSpaces(p1, p2)) {
			// 固定列，左右遍历
			for (Point ph : getHSpaces(pv, p2)) {
				// 再固定行，上下遍历
				if (getVSpaces(ph, p2).contains(p2)) {
					corner1 = ph;
					corner2 = pv;
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * 更新整个游戏界面
	 */
	public void updateAll() {
		setChanged();
		notifyObservers();
	}
  public void pauseDuration(){
	  pauseDuration=pauseDuration+ (int)(System.currentTimeMillis()-pauseTime)/1000;
	  notifyPause();
}
	/**
	 * @return 返回运行时间
	 */
	public int getSeconds() {
		return (int) (System.currentTimeMillis() - startTime) / 1000 - pauseDuration;// 系统的当前时间-开始时间
	}

	/**
	 * 更新游戏界面下面的面板包括(所用时间,剩余本轮可消,历史纪录)
	 */
	private void notifyTimer() {
		setChanged();
		notifyObservers("timer");
	}

	/**
	 * @return 所剩余的图片个数
	 */
	public int getCardLeft() {
		return cardLeft;
	}
/**
 * 
 * @return 剩余时间
 */
	public int getTimeLeft(){
		return timeLeft;
	}
	/**
	 * 
	 * @param time set timeLeft
	 */
	public void setTimeLeft(int time){
		timeLeft=time;
	}
	/**
	 * @return 得到本关的历史纪录
	 */
	public int getHistoryRecord() {
		return historyRecord;
	}

	/**
	 * 计算本轮可以消除的图片对数
	 * 
	 * @return 本轮可消的图片的对数
	 */
	public int solutionCount() {
		int n = 0;
		// 从左到右，从上到下
		for (int row1 = 0; row1 < rows; row1++)
			for (int col1 = 0; col1 < cols; col1++) {
				// 建立一个点p1
				Point p1 = new Point(row1, col1);
				// 从左到右，从上到下
				for (int row2 = 0; row2 < rows; row2++)
					for (int col2 = 0; col2 < cols; col2++) {
						// 建立一个点p2
						Point p2 = new Point(row2, col2);
						// 进行可消性判断
						if (canDelete(p1, p2)) {
							n++;
						}
					}
			}
		return n / 2;// 返回可消的图片的对数
	}

	public boolean showTip() {
		return showTip(false);
	}

	/**
	 * 点击提示时给玩家一条提示线
	 * 
	 * @param b
	 *            返回一个
	 * 
	 * @return boolean 返回一个boolean值说明是否可连
	 */
	private boolean showTip(boolean b) {
		// 从左到右，从上到下
		for (int row1 = 0; row1 < rows; row1++)
			for (int col1 = 0; col1 < cols; col1++) {
				// 建立一个点p1
				Point p1 = new Point(row1, col1);
				// 从左到右，从上到下
				for (int row2 = 0; row2 < rows; row2++)
					for (int col2 = 0; col2 < cols; col2++) {
						// 建立一个点p2
						Point p2 = new Point(row2, col2);
						// 提示
						if (canDelete(p1, p2)) {
							delete(p1, p2, b);
							return true;
						}
					}
			}
		notifyNoSolution();// 否则无解，确定后自动刷新
		refresh();
		return false;
	}

	/**
	 * 开始演示模式
	 */
	public void startDemo() {

		bdemo = true;// 进入演示模式就将它设置成true
		// 建立一个单独的线程用于演示程序
		demoThread = new Thread(new Runnable() {
			public void run() {
				while (cardLeft > 0) {
					if (!showTip(false)) {

					}
					try {// 延迟1秒
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						return;
					}
					showTip(true);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						return;
					}
					updateAll();// 更新
				}
				notifyDemoFinished();
				count = 0;// 演示完成后将提示的次数设为6
				gameStart();// 重新开始游戏
				updateAll();
			}

		});
		demoThread.start();
	}

	/**
	 * 停止演示模式
	 */
	public void stopDemo() {
		bdemo = false;
		while (true) {

			if (!demoThread.isAlive())
				return;
			demoThread.interrupt();// 中断演示
			cardLeft = 0;
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	/* 关于蜗牛工作组信息 */
	public void about() {
		notifyAbout();
	}

	/**
	 * 假如要知道关于信息的时候则自动调用Observer的update()方法，传参"SnailWorkgroup"
	 */
	private void notifyAbout() {
		setChanged();
		notifyObservers("SnailWorkgroup");
	}
	/**
	 * 点击音乐按钮
	 */
	public void clickMusic(){
		notifyClickMusic();
	}
	/**
	 * 通知系统点击了音乐按钮
	 */
	public void notifyClickMusic(){