defaultboardmodel.java

Java编写的小游戏扫雷代码,可以在多种环境下运行

package org.nebula.games.go;


import java.awt.Point;
import java.util.Vector;
import javax.swing.event.*;
import javax.swing.tree.*;

import org.nebula.cwt.grid.*;


public class DefaultBoardModel implements GoBoardModel{

    private DefaultGridModel grids;

	private Vector moves_put;
    private Vector moves_remove;
    
    private int cur_col, cur_row;
    
	public DefaultBoardModel(int bsize) {
		if ((bsize < MIN_BOARD_SIZE) || (bsize > MAX_BOARD_SIZE)) {
			bsize = DEFAULT_BOARD_SIZE;
		}

        System.out.println("board size is " + bsize);
        grids = new DefaultGridModel(bsize, bsize);

 		for (int i = 0 ; i < getBoardSize() ; i++)
  		for (int j = 0 ; j < getBoardSize() ; j++){
            grids.setObject(i, j, new GoPoint());
		}

		moves_put = new Vector();
        moves_remove = new Vector();
        
        setCurrent(-1, -1);
    }
    
//------------------ Board View Interface ------------------------------

    public GridModel getGridModel() {
        return grids;
    }

	/**
	 * property get board size
	 */
	public int getBoardSize(){
		return grids.getRows();
	}

	/**
	 * property get point
	 */
	public GoPoint getPoint(int col, int row){
		return (GoPoint) grids.getObject(col, row);
	}

	public int getMovementCount(){
		return moves_put.size();
	}

    public Movement createMatchRecord() {
        Movement root = new Movement(-1, -1, GoPlayer.BLACK);
        Movement cur = root;
        for (int i = 0; i < moves_put.size(); i++) {
            Movement move = (Movement) moves_put.elementAt(i);
            Movement c = new Movement(move.col, move.row, move.player);
            cur.add(c);
            cur = c;
        }       
        return root; 
    }

    public Movement getLastMovement(){
        if (moves_put.size() == 0)
            return null;

        return (Movement) moves_put.lastElement();
    }
    

    /**
     * clear all point
     */
    public void reset(){
        for (int i = 0 ; i < getBoardSize() ; i++)
        for (int j = 0 ; j < getBoardSize() ; j++){
            getPoint(i, j).setState(GoPoint.EMPTY);
            getPoint(i, j).setNumber(GoPoint.NONE);
            getPoint(i, j).setHolder(GoPlayer.UNKNOWN);
            getPoint(i, j).setSigned(false);
        }
        moves_put.removeAllElements();
        moves_remove.removeAllElements();
        grids.fireDataChanged();
    }

    public void restore() {
        while (moves_remove.size() > 0) {
            undo();
        }
    }


    /**
     * clear all point
     */
    public void reset(int bsize){
		if ((bsize < MIN_BOARD_SIZE) || (bsize > MAX_BOARD_SIZE)) {
			bsize = DEFAULT_BOARD_SIZE;
		}

        grids.reset(bsize, bsize);

 		for (int i = 0 ; i < getBoardSize() ; i++)
  		for (int j = 0 ; j < getBoardSize() ; j++){
            grids.setObject(i, j, new GoPoint());
		}

        moves_put.removeAllElements();
        moves_remove.removeAllElements();
        grids.fireDataChanged();
    }

    /**
     * clear domain mark so that no point show mark
     */
    public void clearDomainMarks(){
        for (int i = 0 ; i < getBoardSize(); i++)
        for (int j = 0 ; j < getBoardSize(); j++){
            getPoint(i, j).setHolder(GoPlayer.UNKNOWN);
        }
    }
    
   	public void setTip(int col, int row, int tip) {
   		getPoint(col, row).setTip(tip);
        grids.fireDataChanged();
    }
	
    public boolean isCurrent(int col, int row) {
        if ((col == cur_col) && (row == cur_row)) {
            return true;
        }
        
        return false;
    }


//------------------ Operation Interface ------------------------------

	public void undo(){
	   
        if (moves_remove.size() > 0) {
            Movement move = (Movement) moves_remove.lastElement();
            
            for (int i = 0 ; i < move.captiveCount() ; i++){
                Movement.Captive p = move.captiveAt(i);
                if (move.player == GoPlayer.BLACK) {
                    getPoint(p.col, p.row).setState(GoPoint.BLACK);
                }
                else {
                    getPoint(p.col, p.row).setState(GoPoint.WHITE);
                }
                getPoint(p.col, p.row).setNumber(p.number);
            }

            moves_remove.removeElement(move);
        }
        else {
            Movement move = (Movement) moves_put.lastElement();
            if (move == null) return;
    
            getPoint(move.col, move.row).setState(GoPoint.EMPTY);
    
            for (int i = 0 ; i < move.captiveCount() ; i++){
                Movement.Captive p = move.captiveAt(i);
                if (move.player == GoPlayer.BLACK) {
                    getPoint(p.col, p.row).setState(GoPoint.WHITE);
                }
                else {
                    getPoint(p.col, p.row).setState(GoPoint.BLACK);
                }
            }
            moves_put.removeElement(move);
            
            if (moves_put.size() > 0) {
                move = (Movement) moves_put.lastElement();
                setCurrent(move.row, move.col);
            }
            else {
                setCurrent(-1, -1);
            }
        }
        grids.fireDataChanged();

	}

	/**
	 * divide domain to black side and white side
	 * empty body blong to it's closest neibor;
	 * if one empty body's neibor don't have same color, it's in neutrality
	 */
    public void divideDomain(){
    	for (int i = 0 ; i < getBoardSize() ; i++)
  		for (int j = 0 ; j < getBoardSize() ; j++){
			getPoint(i, j).setHolder(GoPlayer.UNKNOWN);
		}

   		for (int i = 0 ; i < getBoardSize() ; i++)
  		for (int j = 0 ; j < getBoardSize() ; j++){
            if (getPoint(i, j).getHolder() == GoPlayer.UNKNOWN){
            	if (getPoint(i, j).getState() == GoPoint.BLACK){
                    getPoint(i, j).setHolder(GoPlayer.BLACK);
            	}
            	else if (getPoint(i, j).getState() == GoPoint.WHITE){
                    getPoint(i, j).setHolder(GoPlayer.WHITE);
            	}
            	else {
            		Vector v = getBody(i,j);
            		findSpaceHolder(v);
            	}
            }
		}
    }

    public void performRemove(int x, int y) throws GoException{

		if (!validatePoint(x, y)){
            throw new GoException("Invalid point");
        }

		if (getPoint(x, y).getState() == GoPoint.EMPTY){
            throw new GoException("No chessman to remove");
        }

        Movement move = new Movement(x, y, getPoint(x, y).getState());
		removeBody(x, y, move);
		
		moves_remove.addElement(move);
		
		grids.fireDataChanged();
	}

    public void forcePut(int x, int y, int state) {
        getPoint(x, y).setState(state);
//        System.out.println("force put [" + x + "," + y + "]");
        grids.fireDataChanged();
    }
    
	public void performPut(int x, int y, int player) throws GoException{
        if (moves_remove.size() > 0) {
            throw new GoException("current state: removing");
        }
        
		if (!validatePoint(x, y)){
    		throw new GoException("invalid point!");
		}

        if (getPoint(x, y).getState() != GoPoint.EMPTY){
            throw new GoException("There is already one chessman");
        }
        
        // test put it and check it
        Movement move = new Movement(x, y, player);

        boolean maybeProhibited = false;
		if (moves_put.size() > 0){
            Movement last = (Movement) moves_put.lastElement();
			if (last.captiveCount() == 1){
                Movement.Captive cp = last.captiveAt(0);
				if((cp.col == x) && (cp.row == y)){
					maybeProhibited = true;
				}
			}
		}

        //预先设置，若不成功再移去
		if (player == GoPlayer.BLACK) {
	       	getPoint(x, y).setState(GoPoint.BLACK);
		} else {
	       	getPoint(x, y).setState(GoPoint.WHITE);
		}


		//判断邻近点情况
		//初始时pHand.life=4,代表周围四个点为空点
		//程序可根据pHand.life以及pHand.rub 设置劫的状态
       	int a[] = {x - 1 , x + 1 , x , x};