手机网络象棋开发(4)：核心类Desk, Umpire介绍

今天介绍下Desk、Umpire类

Desk这个类非常重要，可以说是整个服务器框架的核心。

和Server类交互：使用server提供的发送消息的方法，发送消息给特定玩家(全体或者对家)
和LogicHandler交互：提供被调用的具体的方法
包括：玩家坐下、棋子move等等重要动作
和Player类交互：保存该桌子上的玩家
设置玩家到某个桌子
从特定桌子remove 玩家对象
检查player的start状态，决定本周游戏是否可以开始

和Umpire类交互：初始化umpire
启动
判断输赢

详细查看代码
Desk.java

package net.tuolian.newserver;
import java.util.Vector;

/**
 * 
 * @author sean
 * 部分代码来自书本
 *
 */
public class Desk {
	private int ID;					// tableId
	private Player[] players;		// 玩家数组
	private int NUM = 2;			//   每桌玩家个数
	private Player banker = null; 	// 是否庄家
	private int bankerID = 0;	 	// 庄家id
	private Umpire umpire;			// 	裁判
	private int game = 0;   	  	// 
	Server server;

	/**
	 * 游戏桌子
	 */
	public Desk() {
		game = 0;
		server = new Server();
		umpire = new Umpire();
		players = new Player[NUM];    //初始化，本桌子上玩家的数组
		banker = null;
		bankerID = 0;

		for (int i = 0; i < NUM; i++) {
			players[i] = null;
		}
	}
	/**
	 * 初始化
	 */
	public void init() {
		banker = null;
		bankerID = 0;
		game = 0;

		//裁判类进行初始化
		umpire.init();
	}

	/**
	 * 复位
	 */
	public void reset(){
		umpire.init();
		for(int i=0;i<NUM;i++)
			players[i].reset();
	}

	/**
	 * 开始游戏
	 * 确定红、白
	 * 发送消息给各自的玩家
	 * 发送轮次
	 */
	public void start() {
		players[bankerID].setColor("red");
		players[(bankerID+1)%NUM].setColor("white");
		sendMessage(players[bankerID], "color:"+players[bankerID].getColor());
		sendMessageToOther(players[bankerID],"color:"+players[(bankerID+1)%NUM].getColor());
		sendMessage(players[bankerID], "turn");
	}

	/**
	 * 移动棋子
	 * 解析message
	 * 调用裁判的moveChess方法
	 * 发送消息给对方
	 * 
	 * 如果出现胜负、则发送win消息给双方
	 * @param message
	 */
	public void moveChess(String message) {
		int index0 = message.indexOf(";");
		int index1 = message.indexOf(":");
		int index2 = message.indexOf(",", index1 + 1);
		int index3 = message.indexOf(",", index2 + 1);
		int index4 = message.indexOf(",", index3 + 1);

		int seat = Integer.parseInt(message.substring(index0 + 1, index1));
		int selectedY = Integer.parseInt(message.substring(index1 + 1, index2));
		int selectedX = Integer.parseInt(message.substring(index2 + 1, index3));
		int n = Integer.parseInt(message.substring(index3 + 1, index4));
		int m = Integer.parseInt(message.substring(index4 + 1));

		//移动棋子，发送消息给对家
		umpire.moveChess(selectedY, selectedX, n, m);
		sendMessageToOther(players[seat], message);

		//判断是否有输赢结果，如果有的话，发送相应的消息，扩展：进展游戏的结果的保存，比如分数等
		if (Umpire.isWhiteWin == 0) {
			sendMessage(players[bankerID], "win,you");
			sendMessageToOther(players[bankerID], "win");
			bankerID = (seat + 1) % NUM;
			reset();
		} else if (Umpire.isRedWin == 0) {
			sendMessage(players[(bankerID+1)%NUM], "win,you");
			sendMessageToOther(players[(bankerID+1)%NUM], "win");
			bankerID = (seat + 1) % NUM;
			reset();
		}
	}
	public int getID() {
		return ID;
	}
	public void setID(int id) {
		ID = id;
	}
	public Player getBanker() {
		return banker;
	}
	public void setBanker(Player banker) {
		this.banker = banker;
	}
	public int getGame() {
		return game;
	}

	/**
	 * 必须所有人满桌才可以开始游戏
	 * 桌子上的玩家为空，false
	 * 桌子上玩家的状态没有开始， false
	 * @return
	 */
	public boolean isReady() // 
	{
		for (int i = 0; i < NUM; i++) {
			if (players[i] == null)
				return false;
			else if (!players[i].isStart())
				return false;
		}

		//裁判类初始化，启动逻辑判断
		umpire.init();
		return true;
	}

	/**
	 * 判断当前座位是否为空
	 * @param pos
	 * @return
	 */
	public boolean isEmpty(int pos) {// 
		if (pos >= NUM)
			return false;
		return players[pos] == null;
	}

	/**
	 * 设置坐庄者
	 * @return
	 */
	public int getBankerID() {
		return bankerID;
	}

	/**
	 * 获得当前桌子的玩家数
	 * @return
	 */
	public int getPlayersCounter() {
		return NUM;
	}

	/**
	 * 获得玩家数组
	 * @return
	 */
	public Player[] getPlayers() {
		return players;
	}

	/**
	 * 获得指定玩家
	 * 判断数组是否为空，是，则进行下次循环
	 * 否则查看数组中玩家是否等于传入的玩家对象
	 * @param p
	 * @return
	 */
	public int getPlayerSeat(Player p) 
	{
		for (int i = 0; i < NUM; i++) {
			if (players[i] == null)
				continue;
			if (players[i].equals(p))
				return i;
		}
		return -1;
	}

	/**
	 * 设置玩家
	 * @param pos
	 * @param p
	 */
	public void setPlayer(int pos, Player p) {
		if (pos >= NUM)
			return;
		players[pos] = p;
	}

	/**
	 * 去掉某个指定玩家
	 * @param p
	 */
	public void removePlayer(Player p) {// �Ƴ����p
		for (int i = 0; i < NUM; i++) {
			if (players[i] == null)
				continue;
			else if (players[i].equals(p))
				players[i] = null;
		}
	}

	/**
	 * 发送消息给所有玩家
	 * @param mes
	 */
	public void sendMessageToAll(String mes) {
		for (int i = 0; i < NUM; i++)
			if (players[i] != null)
				sendMessage(players[i], mes);
	}

	/**
	 * 发送消息给游戏的对家
	 * 根据playerId比较，如果是本人就跳出本次循环
	 * 否则发送消息
	 * @param player
	 * @param message
	 */
	public void sendMessageToOther(Player player, String message) {
		for (int i = 0; i < NUM; i++) {
			System.out.println("玩家id比较: " + (players[i].getID() == player.getID()));
			System.out.println("玩家比较：" +players[i].equals(player));
			if (players[i] != null){
				if(players[i].getID() == player.getID()){
					continue;
				}
				else{
					sendMessage(players[i], message);
				}
			}
		}
	}

	/**
	 * 发送消息给指定玩家
	 * 调用server的发送消息方式，
	 * 在后者的方法中：提取消息的各个部分，二进制方式写到网络流
	 * @param p
	 * @param m
	 */
	public void sendMessage(Player p, String m) {
		Server.sendMessage(p, m);
	}
}

Umpire.java
主要功能：
游戏核心逻辑的启动、判断、移动等等
具体算法，还需要花费时间加深理解。
今后可以进一步将通信、逻辑(大厅、游戏逻辑等）封装，加强后续的扩展和维护性。
具体参考代码

package net.tuolian.newserver;

/**
 * 
 * @author sean
 * 裁判类
 * 1. 构造函数
 * 2. 
 *
 */
public class Umpire {
	private int huihe;
	private int score;
	protected static int i, j;
	protected static int isRedWin = 1, isWhiteWin = 1;// 
	private int point[][];			//棋牌坐标

	/**
	 * 构造方法
	 */
	public Umpire() {
		huihe = 0;
		score = 0;

		point = new int[][] { { 1, 2, 3, 4, 5, 6, 7, 8, 9 },// 
				{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
				{ 0, 10, 0, 0, 0, 0, 0, 11, 0 },
				{ 12, 0, 13, 0, 14, 0, 15, 0, 16 },
				{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
				{ 0, 0, 0, 0, 0, 0, 0, 0, 0 },
				{ 28, 0, 29, 0, 30, 0, 31, 0, 32 },
				{ 0, 26, 0, 0, 0, 0, 0, 27, 0 },
				{ 0, 0, 0, 0, 0, 0, 0, 0, 0 },
				{ 17, 18, 19, 20, 21, 22, 23, 24, 25 } };
	}

	/**
	 * 分析输赢结果
	 */
	public void checkWin() {// 
		isRedWin = 0;
		isWhiteWin = 0;
		for (i = 0; i < 3; i++) {
			for (j = 0; j < 3; j++) {
				if (point[0 + i][3 + j] == 5) {
					isRedWin++;
				}
			}
		}
		for (i = 0; i < 3; i++) {
			for (j = 0; j < 3; j++) {
				if (point[7 + i][3 + j] == 21) {
					isWhiteWin++;
				}
			}
		}
	}

	/**
	 * 移动棋子
	 * @param selectedY
	 * @param selectedX
	 * @param n
	 * @param m
	 */
	public void moveChess(int selectedY, int selectedX, int n, int m) {
		point[selectedY][selectedX] = point[n][m];
		point[n][m] = 0;
		checkWin();
	}

	/**
	 * 
	 */
	public void logHuihe() {
		huihe++;
	}

	/**
	 * 
	 * @return
	 */
	public int getHuihe() {
		return huihe;
	}

	/**
	 * 初始化
	 */
	public void init() {
		System.out.println("裁判程序初始化完成");
		huihe = 0;
		score = 0;
		isRedWin = 1;
		isWhiteWin = 1;
		point = new int[][] { { 1, 2, 3, 4, 5, 6, 7, 8, 9 },
				{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
				{ 0, 10, 0, 0, 0, 0, 0, 11, 0 },
				{ 12, 0, 13, 0, 14, 0, 15, 0, 16 },
				{ 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
				{ 0, 0, 0, 0, 0, 0, 0, 0, 0 },
				{ 28, 0, 29, 0, 30, 0, 31, 0, 32 },
				{ 0, 26, 0, 0, 0, 0, 0, 27, 0 }, 
				{ 0, 0, 0, 0, 0, 0, 0, 0, 0 },
				{ 17, 18, 19, 20, 21, 22, 23, 24, 25 } };
	}

	public int score() {
		return score;
	}

	public void clearScore() {
		score = 0;
	}

	public void clearhuihe() {
		huihe = 0;
	}
}