model.java

java lian kan 小游戏代码

package model;


import java.awt.Point;
import java.util.ArrayList;
import java.util.Observable;
import java.util.Random;


public class Model extends Observable{
	public static final int CARD_NUMBERS=44;
	
	private int level;

	private int rows=11,cols=19;

	private int[][] data;

	private Point sltMatrix;

	private Point corner1,corner2;

	private long startTime;

	private boolean bPlaying;

	private int leave;
	
	private int total;
	
	private int historyRecord;
	
	private  Thread t;
	
	private Thread demoThread;
	
	//private int nSolution;
	
	public Model(){
		loadSet();
		t=new Thread(new Runnable() {
			public void run() {
					while(true){

						synchronized(t){ 
							if(!bPlaying){
								try {
									t.wait();
								} catch (InterruptedException e) {
									e.printStackTrace();
								}
							}

							try {
								t.wait(500);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							notifyTimer();
						}
				}
			}

		});
		t.start();
		restartGame();
	}

	private void loadSet() {
		frameLocation=LoadAndSave.loadLocation();
		level=LoadAndSave.loadLevel();
	}

	public void cancelSelect(){
		sltMatrix=null;
		updateAll();
	}
	private boolean canDelete(Point p1,Point p2){
		if(p1.equals(p2)||data[p1.x][p1.y]!=data[p2.x][p2.y]||data[p1.x][p1.y]==0||data[p2.x][p2.y]==0) return false;
		corner1=null;
		corner2=null;
		return noCorner(p1, p2)||oneCorner(p1,p2)||twoCorner(p1,p2);
	}


	public void clickMatrix(Point p){
		if(p.x<0||p.y<0||p.x>=rows||p.y>=cols||!bPlaying) return;
		if(isEmpty(p)) return;
		if(null==sltMatrix){
			sltMatrix=p;
		}
		else if(canDelete(sltMatrix,p)){
			delete(sltMatrix,p,true);
			sltMatrix=null;
		}
		else{
			sltMatrix=p;
		}
		if(leave==0){
			bPlaying=false;
			LoadAndSave.saveRecord(total,getSeconds());
			notifyFinished();
			if(getSeconds()<historyRecord){
				notifyBreakRecord();
				historyRecord=getSeconds();
			}
		}
		if(solutionCount()==0){
			refresh();
		}
		updateAll();
	}


	private void notifyBreakRecord() {
		setChanged();
		notifyObservers("breakrecord");
	}

	private void notifyNoSolution(){
		setChanged();
		notifyObservers("nosolution");
	}
	private void notifyDemoFinished() {
		setChanged();
		notifyObservers("demofinished");
	}
	
	private void notifyFinished() {
		setChanged();
		notifyObservers("finished");
	}

	private void delete(Point p){
		data[p.x][p.y]=0;
		leave--;
		updateAll();
	}

	private void delete(Point p1,final Point p2 , boolean bDelete){
		//if(noCorner(p1,p2)) 
		ArrayList<Point> points=new ArrayList<Point>();
		if(corner1==null){

			points.add(p1);
			points.add(p2);
			//notifyEffect(points);
		}
		else if(corner2==null){
			//ArrayList<Point> points=new ArrayList<Point>();
			points.add(p1);
			points.add(corner1);
			points.add(p2);
			//notifyEffect(points);
		}
		else{
			//ArrayList<Point> points=new ArrayList<Point>();
			if(p1.x!=corner1.x&&p1.y!=corner1.y){
				Point pt=corner1;
				corner1=corner2;
				corner2=pt;
			}
			points.add(p1);
			points.add(corner1);
			points.add(corner2);
			points.add(p2);
			//notifyEffect(points);
		}
		if(bDelete){
			delete(p1);	delete(p2);	
		}
		notifyEffect(points);
	}
	public int getCols() {
		return cols;
	}

	private ArrayList<Point> getHSpaces(Point p,Point pg){
		ArrayList<Point> ps=new ArrayList<Point>();
		//left
		for(int dif=1; ;dif++){
			int col=p.y-dif;
			int row=p.x;
			if(col<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+dif;
			int row=p.x;
			if(col>=cols||(data[row][col]!=0&&!pg.equals(new Point(row,col)))) break;
			ps.add(new Point(row,col));
		}
		return ps;
	}

	public int[][] getMaps(){
		return data;
	}

	public int getRows() {
		return rows;
	}

	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;
			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;
			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];
		int sNums[]=null;
		switch(level){
		case 1:
			sNums=numberSelector(1,CARD_NUMBERS,10);
			break;
		case 2:
			sNums=numberSelector(1,CARD_NUMBERS,14);
			break;
		case 3:
			sNums=numberSelector(1,CARD_NUMBERS,18);
			break;
		case 4:
			sNums=numberSelector(1,CARD_NUMBERS,22);
			break;
		case 5:
			sNums=numberSelector(1,CARD_NUMBERS,26);
			break;
		case 6:
			sNums=numberSelector(1,CARD_NUMBERS,30);
			break;
		case 7:
			sNums=numberSelector(1,CARD_NUMBERS,34);
			break;
		case 8:
			sNums=numberSelector(1,CARD_NUMBERS,38);
			break;
		case 9:
			sNums=numberSelector(1,CARD_NUMBERS,CARD_NUMBERS);
			break;
		default:
			sNums=numberSelector(1,CARD_NUMBERS,new Random().nextInt(CARD_NUMBERS)+1);
		}
		for(int i=0;i<sNums.length;i++){
			for(int j=0;j<4;j++){
				int index=i*4+j;
				int row=index/cols;
				int col=index%cols;
				data[row][col]=sNums[i];
			}
		}
		leave=total=sNums.length*4;
		historyRecord=LoadAndSave.getRecord(total);
		//nSolution=solutionCount();
	}
	private boolean isEmpty(Point p) {
		return 0==data[p.x][p.y];
	}
	private boolean noCorner(Point p1,Point p2){
		return getHSpaces(p1,p2).contains(p2)||getVSpaces(p1,p2).contains(p2);
	}

	private void notifyEffect(ArrayList<Point> points){
		setChanged();
		notifyObservers(points);
	}

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

	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;
	}

	private void randomSort(){
		ArrayList<Integer> list=new ArrayList<Integer>();
		for(int i=0;i<data.length;i++)
			for(int j=0;j<data[0].length;j++){
				list.add(new Integer(data[i][j]));
			}
		for(int i=0;i<data.length;i++)
			for(int j=0;j<data[0].length;j++){
				data[i][j]=list.remove(new Random().nextInt(list.size()));
			}
		sltMatrix=null;
	}

	public void refresh() {
		//if(!bPlaying) return;
		randomSort();
		updateAll();
	}

	public void restartGame() {
		
			initData();
			randomSort();
			
			bPlaying=true;
		synchronized(t){
			t.notify();
			startTime=System.currentTimeMillis();
		}
		updateAll();
	}

	public void setSltMatrix(Point sltMatrix) {
		this.sltMatrix = sltMatrix;
	}

	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 setLevel(int level) {
		this.level=level;
	}

	public int getSeconds() {
		return (int) (System.currentTimeMillis()-startTime)/1000;
	}

	private void notifyTimer() {
		setChanged();
		notifyObservers("timer");
	}

	public int getLeave() {
		return leave;
	}

	public int getHistoryRecord() {
		return historyRecord;
	}
	
	public int solutionCount(){
		int n=0;
		for(int row1=0;row1<rows;row1++)
			for(int col1=0;col1<cols;col1++){
				Point p1=new Point(row1,col1);
				for(int row2=0;row2<rows;row2++)
					for(int col2=0;col2<cols;col2++){
						Point p2=new Point(row2,col2);
						if(canDelete(p1,p2)){
							//return false;
							n++;
						}
					}
			}
		return n/2;
	}
	
	public boolean showTip(){
		return showTip(false);
	}
	private boolean showTip(boolean b){
		for(int row1=0;row1<rows;row1++)
			for(int col1=0;col1<cols;col1++){
				Point p1=new Point(row1,col1);
				for(int row2=0;row2<rows;row2++)
					for(int col2=0;col2<cols;col2++){
						Point p2=new Point(row2,col2);
						if(canDelete(p1,p2)){
							delete(p1,p2,b);
							return true;
						}
					}
			}
		notifyNoSolution();
		refresh();
		return false;
	}
	
	public void startDemo(){
		demoThread=new Thread(new Runnable() {
			public void run() {
				while(leave>0){
					if(!showTip(false)){

					}
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						return;
					}
					showTip(true);
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						return;
					}
					updateAll();
				}
				bPlaying=false;
				notifyDemoFinished();
				updateAll();
			}

		});
		demoThread.start();
	}
	
	public void stopDemo(){
		while(true){
			
			if(!demoThread.isAlive()) return;
			demoThread.interrupt();
			leave=0;
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	public int getLevel() {
		// TODO Auto-generated method stub
		return level;
	}

	public void about() {
		notifyAbout();
	}

	private void notifyAbout() {
		setChanged();
		notifyObservers("about");
	}

	private Point frameLocation;
	public Point getLocation() {
		// TODO Auto-generated method stub
		return frameLocation;
	}

	public void saveSet() {
		LoadAndSave.saveLevel(level);
		if(frameLocation!=null){
			LoadAndSave.saveLocation(frameLocation);
		}
	}

	public void setFrameLocation(Point location) {
		frameLocation=location;
	}
	
}