放炮罚增加名堂优先判断

game_common/src/main/java/com/game/GameController.java

@@ -303,6 +303,7 @@ public class GameController implements IController {
 				}
 			}
 			player = MainServer.instance.newPlayer(playerid, owner, session_key);
+			//这里判断了加入房间后的最高限制分，需要调整代码
 			if (player.room.upper_limit_hp == 0 || player.room.upper_limit_hp > cur_hp) {
 				player.room.upper_limit_hp = cur_hp;
 			}

game_mj_hongzhong/src/main/java/extend/mj/RoomCard.java

@@ -170,8 +170,11 @@ public class RoomCard {
 					int indexhh = this.cardList.indexOf(Config.HONGZHONG);
 					// Global.logger.info("hongzhongid:"+indexhh+"card"+this.cardList);
 					dealCards.add(Config.HONGZHONG);
-					this.cardList.remove(indexhh);
+					if(indexhh!=0) {
-					Collections.shuffle(this.cardList);
+						this.cardList.remove(indexhh);
+						Collections.shuffle(this.cardList);
+
+					}
 				}
 				for (int index = 0; index < 13 - flag; index++) {
 					dealCards.add(this.pop());

game_mj_hongzhong/src/main/java/extend/mj/room/state/EXRoomStartGameState.java

@@ -21,7 +21,7 @@ public class EXRoomStartGameState extends StateBase<EXRoom> {
 //			player.initSeat();
 //		}
 		owner.startGame();
-		
+		//游戏开始前重新计算最高限制分------------------------
 		this.toNextState(owner);
 	}
 

game_zp_fangpaofa/src/main/java/extend/zp/EXRoom.java

@@ -35,6 +35,10 @@ public class EXRoom extends Room {
 	public RoomCard card;
 
 	public int activeCard;
+	public int checkPaoActiveCard;
+	public int checkPaoActiveSeat;
+
+
 	public int drawCard;
 	public int currenDiscardSeat;
 	public int lastDiscardSeat;
@@ -85,6 +89,8 @@ public class EXRoom extends Room {
 	public int adminSeat;
 
 	public boolean jiesanflag = false;
+	
+	public Set<Integer> broadCard =new HashSet<Integer>();
 
 	public EXRoom(String roomid, Map<String, String> redis_room_map) {
 		super(roomid, redis_room_map);
@@ -492,7 +498,7 @@ public class EXRoom extends Room {
 		player.mingtangList.clear();
 		player.winFan = 1;
 		int score = 0;
-
+//		logger.info("是否听胡:"+this.isTianHu+"---"+player.playerid);
 		if (this.isTianHu) {
 			// 天胡
 			if (player.seat == this.bankerSeat) {
@@ -506,9 +512,15 @@ public class EXRoom extends Room {
 			}
 		}
 		// 判断房间是否有出牌
+//		logger.info("地胡："+player.getRoom().roomoutcardlist.size());
+//		logger.info("地胡："+player.outcardList.size());
+//		logger.info("地胡："+player.getRoom().card.cardList.size());
 
-		if (player.getRoom().roomoutcardlist.size() == 1 && player.outcardList.size() == 0) {
+		if (player.getRoom().roomoutcardlist.size() == 1 && player.outcardList.size() == 0 && player.getRoom().card.cardList.size() >=19) {
-			if (player.getRoom().activeCard == player.getRoom().roomoutcardlist.get(0)) {
+//			logger.info(player.getRoom().roomoutcardlist.size()+"---这里是出牌集合player.getRoom().roomoutcardlist.get(0):"+player.getRoom().roomoutcardlist.get(0));
+//			logger.info("这里是当前行动的牌player.getRoom().activeCard"+player.getRoom().activeCard);
+
+			if (player.getRoom().activeCard == player.getRoom().roomoutcardlist.get(0) || player.getRoom().activeCard==0) {
 				mingtangflag = true;
 				player.mingtangList.add(new MingTang(RuleWeight.DI_HU, 1, 100));
 			}
@@ -566,6 +578,10 @@ public class EXRoom extends Room {
 			}
 
 			// 自摸
+//			logger.info("检测自摸是否来到这里："+(this.winSeat == player.seat));
+//			logger.info("检测自摸是否来到这里："+(player.ispengchiwin == false));
+//			logger.info("检测自摸是否来到这里："+(!this.isFanPao));
+
 			if (this.winSeat == player.seat && player.ispengchiwin == false && !this.isFanPao) {
 				player.winFan = player.winFan * 2;
 				player.mingtangList.add(new MingTang(RuleWeight.ZI_MO, 2, 2));
@@ -1342,7 +1358,7 @@ public class EXRoom extends Room {
 	public void endGame() {
 		// this.endflag = this.entrustTotal();
 		// 如果是流局则：给庄家-10
-		if (this.liuju) {
+		if (this.liuju && this.card.cardList.size()==0) {
 			for (Entry<Integer, Player> entry : this.playerMapById.entrySet()) {
 				EXPlayer player = (EXPlayer) entry.getValue();
 				if (player.seat == this.bankerSeat) {
@@ -1458,10 +1474,13 @@ public class EXRoom extends Room {
 		this.weiRoomGroup.clear();
 		this.roomoutcardlist.clear();
 		this.paochucardlist.clear();
+		this.card=new RoomCard(this);
 
 		this.isFanPao = false;
 		this.endflag = false;
 		this.fangpaosubvalue = 0;
 		this.yikuaibianflag = false;
+		this.broadCard.clear();
+		
 	}
 }

game_zp_fangpaofa/src/main/java/extend/zp/PlayerRuleManager.java

@@ -5,8 +5,10 @@ import java.util.HashMap;
 import java.util.List;
 
 import com.game.Global;
+import com.taurus.core.util.Logger;
 
 import extend.zp.player.rule.*;
+import extend.zp.player.rulestate.PRDiscardPaoState;
 import extend.zp.player.state.EXPlayerDisCardTipState;
 import extend.zp.player.state.EXPlayerDrawTipState;
 import extend.zp.player.state.EXPlayerTipState;
@@ -26,6 +28,7 @@ public class PlayerRuleManager {
 
 	public HashMap<Integer, List<IRuleBase>>	ruleMap			= null;
 	public HashMap<Integer, EXPlayerTipState>	tipMap			= null;
+	public static final Logger logger = Logger.getLogger(PlayerRuleManager.class);
 
 	public PlayerRuleManager() {
 		ruleMap = new HashMap<Integer, List<IRuleBase>>();
@@ -71,15 +74,21 @@ public class PlayerRuleManager {
 		ruleMap.put(PlayerRuleManager.DRAW_PAO_RULE, drawPaoList);
 
 		List<IRuleBase> otherDiscardList = new ArrayList<IRuleBase>();
-		otherDiscardList.add(new RuleDrawWin());//放炮
+		
 		otherDiscardList.add(new RuleDiscardPao());
+		otherDiscardList.add(new RulePaoWin());
+		otherDiscardList.add(new RuleDrawWin());//放炮
+
 		otherDiscardList.add(new RulePong());
 		otherDiscardList.add(new RuleChi());
+
 		ruleMap.put(PlayerRuleManager.DISCARD_RULE, otherDiscardList);
 
 		List<IRuleBase> huList = new ArrayList<IRuleBase>();
-		huList.add(new RuleWin());
 		huList.add(new RuleWei());
+		huList.add(new RuleWin());
+//		huList.add(new RulePaoWin());
+
 		ruleMap.put(PlayerRuleManager.HU_RULE, huList);
 
 		List<IRuleBase> otherHuList = new ArrayList<IRuleBase>();

game_zp_fangpaofa/src/main/java/extend/zp/RoomCard.java

@@ -28,12 +28,12 @@ public class RoomCard {
 	public void init() {
 //		this.cardList.clear();
 //		this.subCardList.clear();
-//		this.sanlong();
+		this.sanlong();
 
-		this.initCard();
+//		this.initCard();
-		this.shuffle();
+//		this.shuffle();
-		this.subCard(); //抽牌
+//		this.subCard(); //抽牌
-		this.shuffle();
+//		this.shuffle();
 
 		// this.testhuxi();
 
@@ -63,11 +63,164 @@ public class RoomCard {
 	}
 
 	public void sanlong() {
-		
+		List list2 = Arrays.asList(102, 103, 103, 103, 104, 105, 106, 106, 107, 107, 108, 109, 201, 203, 204, 204, 205, 205, 208, 208);
-		List list2 = Arrays.asList(102, 103, 105, 106, 107, 107, 108, 109, 201, 202, 203, 203, 206, 206, 207, 208, 208, 208, 209, 210);
+		List list = Arrays.asList(101, 101, 103, 104, 105, 108, 109, 109, 110, 110, 202, 202, 203, 203, 205, 206, 208, 209, 209, 210);
-		List list = Arrays.asList(101, 101, 104, 104, 109, 109, 110, 110, 110, 201, 201, 202, 203, 204, 204, 205, 205, 207, 208, 210);
+		List list3 = Arrays.asList(109, 106, 206, 203, 102, 201, 105, 207, 208, 207, 101, 209, 108, 206, 105, 204, 210, 206, 201, 202);
-		List list3 = Arrays.asList(209, 205, 109, 104, 202, 204, 201, 206, 101, 105, 106, 101, 203, 210, 205, 102, 103, 204, 206, 207);
 
+		//596912 大九不能胡
+//		List list2 = Arrays.asList(101, 102, 102, 104, 105, 105, 105, 107, 107, 107, 110, 203, 204, 205, 206, 207, 208, 208, 209, 210);
+//		List list = Arrays.asList(101, 101, 102, 103, 103, 104, 106, 106, 106, 106, 108, 108, 201, 201, 202, 203, 205, 206, 206, 207);
+//		List list3 = Arrays.asList(109, 101, 102, 103, 110, 210, 105, 103, 109, 210, 108, 205, 202, 109, 201, 202, 104, 201, 209, 205);
+
+//		//178466 大一不能胡
+//		List list2 = Arrays.asList(101, 102, 103, 104, 104, 106, 106, 106, 107, 108, 109, 201, 201, 202, 204, 204, 205, 205, 207, 209);
+//		List list = Arrays.asList(101, 103, 104, 104, 105, 107, 107, 108, 109, 109, 110, 201, 202, 203, 204, 205, 206, 206, 208, 210);
+//		List list3 = Arrays.asList(203, 210, 209, 110, 106, 206, 105, 208, 102, 203, 204, 205, 110, 208, 209, 207, 103, 210, 103, 207);
+
+//		//131987 畏起不算自摸
+//		List list2 = Arrays.asList(101, 101, 103, 104, 104, 104, 105, 105, 110, 110, 201, 201, 202, 202, 203, 206, 207, 207, 207, 210);
+//		List list = Arrays.asList(101, 102, 104, 106, 108, 108, 109, 110, 201, 201, 202, 204, 204, 204, 206, 207, 208, 208, 209, 209);
+//		List list3 = Arrays.asList(210, 107, 103, 108, 204, 105, 103, 107, 101, 102, 108, 210, 203, 109, 105, 206, 106, 202, 208, 205);
+
+//		//385250 大九不能胡
+//		List list2 = Arrays.asList(101, 101, 104, 104, 104, 108, 109, 109, 201, 202, 203, 204, 204, 205, 206, 207, 208, 209, 210, 210);
+//		List list = Arrays.asList(101, 102, 102, 102, 103, 103, 103, 104, 106, 106, 107, 108, 109, 201, 201, 203, 203, 206, 209, 210);
+//		List list3 = Arrays.asList(103, 206, 207, 202, 207, 101, 203, 110, 205, 107, 107, 102, 202, 209, 206, 106, 109, 209, 201, 205);
+
+//		// 387894_1 卡死未准备
+//		List list2 = Arrays.asList(102, 102, 104, 104, 201, 201, 203, 203, 203, 204, 205, 205, 205, 206, 206, 206, 207, 208, 210, 210);
+//		List list = Arrays.asList(101, 102, 103, 103, 104, 105, 105, 108, 108, 109, 109, 110, 110, 202, 204, 204, 206, 207, 208, 210);
+//		List list3 = Arrays.asList(202, 109, 106, 107, 106, 110, 202, 106, 202, 205, 208, 207, 209, 109, 106, 105, 107, 101, 104, 102);
+
+//		// 590898_6 多一张小八
+//		List list2 = Arrays.asList(102, 102, 104, 105, 105, 105, 106, 108, 110, 110, 201, 202, 202, 205, 206, 207, 208, 209, 210, 210);
+//		List list = Arrays.asList(101, 101, 103, 104, 104, 106, 109, 110, 201, 201, 203, 204, 204, 205, 208, 208, 208, 209, 209, 210);
+//		List list3 = Arrays.asList(107, 108, 206, 106, 103, 107, 101, 110, 203, 205, 106, 210, 206, 103, 105, 102, 202, 209, 207, 108);
+
+		
+//		// 590898_6 多一张小八
+//		List list2 = Arrays.asList(102, 104, 105, 106, 106, 106, 107, 108, 109, 110, 201, 202, 203, 204, 204, 206, 206, 207, 209, 210);
+//		List list = Arrays.asList(101, 103, 105, 105, 106, 107, 107, 109, 110, 201, 202, 205, 205, 206, 207, 207, 208, 210, 210, 210);
+//		List list3 = Arrays.asList(104, 201, 102, 203, 208, 204, 101, 203, 202, 204, 103, 208, 109, 110, 102, 201, 209, 102, 103, 103);
+
+		//地胡
+//		List list2 = Arrays.asList(101, 102, 103, 201, 202, 203, 202, 207, 210, 205, 205, 205, 105, 106, 107, 108, 108, 208, 209, 210);
+//		List list = Arrays.asList(101, 102, 102, 104, 104, 205, 106, 107, 103, 104, 108, 109, 109, 110, 201, 201, 203, 204, 206, 207);
+//		List list3 = Arrays.asList(108, 108, 208, 210, 103, 105, 109, 102, 103, 107, 109, 106, 209, 103, 207, 104, 206, 205, 209, 205);
+
+//		//测试856802_6 单调不能胡
+//		List list2 = Arrays.asList(101, 103, 104, 107, 107, 108, 110, 110, 201, 202, 203, 203, 203, 204, 204, 205, 206, 208, 209, 210);
+//		List list = Arrays.asList(101, 102, 102, 104, 104, 106, 106, 107, 108, 108, 108, 109, 109, 110, 201, 201, 203, 204, 206, 207);
+//		List list3 = Arrays.asList(102, 105, 208, 210, 103, 105, 109, 102, 103, 107, 109, 106, 209, 103, 207, 104, 206, 205, 209, 205);
+
+//		//918864_3胡息没结算
+//		List list2 = Arrays.asList(101, 102, 102, 104, 105, 105, 105, 108, 109, 110, 201, 202, 204, 206, 206, 206, 207, 207, 208, 210);
+//		List list = Arrays.asList(103, 104, 105, 107, 107, 107, 108, 108, 109, 110, 202, 204, 205, 208, 208, 209, 209, 209, 210, 210);
+//		List list3 = Arrays.asList(203, 106, 101, 102, 106, 201, 201, 103, 109, 101, 106, 209, 206, 203, 106, 201, 102, 207, 104, 110);
+
+//		//651696胡息不对
+//		List list2 = Arrays.asList(101, 101, 103, 104, 107, 108, 109, 110, 201, 202, 203, 204, 204, 204, 205, 206, 206, 208, 208, 209);
+//		List list = Arrays.asList(102, 102, 102, 103, 103, 105, 108, 109, 110, 201, 202, 202, 203, 203, 204, 205, 207, 209, 210, 210);
+//		List list3 = Arrays.asList(203, 202, 207, 209, 106, 104, 109, 105, 201, 103, 101, 206, 109, 110, 108, 106, 207, 208, 106, 104);
+
+//		//起手提并且对家打了跑
+//		List list2 = Arrays.asList(106, 106, 107, 108, 108, 109, 110, 201, 202, 203, 203, 203, 204, 204, 204, 205, 206, 208, 208, 209);
+//		List list = Arrays.asList(101, 101, 101, 102, 102, 102, 102, 103, 105, 201, 201, 201, 204, 206, 207, 207, 209, 209, 210, 210);
+//		List list3 = Arrays.asList(207, 108, 103, 202, 110, 108, 106, 207, 103, 110, 104, 105, 109, 107, 203, 107, 209, 109, 103, 206);
+
+//		//海底胡显示异常
+//		List list2 = Arrays.asList(101, 101, 103, 105, 106, 108, 108, 109, 201, 202, 203, 203, 204, 205, 207, 208, 208, 208, 210, 210);
+//		List list = Arrays.asList(104, 104, 106, 107, 107, 108, 108, 110, 110, 201, 202, 202, 204, 204, 204, 205, 205, 205, 207, 209);
+//		List list3 = Arrays.asList(201, 210, 103, 209, 206, 107, 105, 206, 207, 106, 103, 101, 105, 107, 109, 202, 208, 109, 207, 101);
+
+//		//275664提完点胡没反应
+//		List list2 = Arrays.asList(101, 102, 102, 104, 105, 107, 108, 201, 202, 202, 202, 203, 206, 207, 207, 207, 207, 208, 209, 210);
+//		List list = Arrays.asList(103, 104, 105, 106, 106, 110, 110, 201, 203, 203, 203, 204, 204, 205, 205, 205, 209, 210, 210, 210);
+//		List list3 = Arrays.asList(209, 107, 108, 103, 109, 208, 208, 101, 102, 101, 106, 209, 201, 102, 103, 109, 204, 206, 109, 206);
+
+//		//599876按最大胡息
+//		List list2 = Arrays.asList(101, 102, 103, 106, 108, 109, 109, 110, 110, 201, 201, 202, 203, 206, 207, 207, 208, 209, 209, 209);
+//		List list = Arrays.asList(101, 104, 105, 106, 106, 107, 108, 108, 110, 201, 202, 204, 205, 206, 207, 208, 208, 209, 210, 210);
+//		List list3 = Arrays.asList(102, 108, 107, 207, 101, 204, 102, 205, 208, 103, 104, 103, 105, 109, 109, 210, 206, 205, 106, 204);
+
+		//554601按最大胡息
+//		List list2 = Arrays.asList(101, 201, 203, 103, 107, 107, 108, 109, 202, 202, 203, 204, 204, 205, 207, 208, 209, 209, 209, 210);
+//		List list = Arrays.asList(101, 104, 104, 105, 106, 106, 107, 107, 109, 110, 202, 204, 205, 206, 206, 206, 207, 207, 207, 209);
+//		List list3 = Arrays.asList(210, 109, 101, 210, 108, 109, 104, 205, 103, 208, 202, 108, 201, 106, 201, 110, 101, 106, 110, 102);
+
+		//554601按最大胡息
+//		List list2 = Arrays.asList(101, 102, 102, 103, 107, 107, 108, 109, 202, 202, 203, 204, 204, 205, 207, 208, 209, 209, 209, 210);
+//		List list = Arrays.asList(101, 104, 104, 105, 106, 106, 107, 107, 109, 110, 202, 204, 205, 206, 206, 206, 207, 207, 207, 209);
+//		List list3 = Arrays.asList(210, 109, 101, 210, 108, 109, 104, 205, 103, 208, 202, 108, 201, 106, 201, 110, 101, 106, 110, 102);
+
+		//613649不能胡
+//		List list2 = Arrays.asList(101, 102, 102, 103, 104, 105, 106, 106, 107, 109, 110, 202, 205, 206, 207, 207, 208, 210, 210, 210);
+//		List list = Arrays.asList(101, 101, 103, 103, 104, 104, 105, 106, 107, 108, 109, 110, 201, 203, 205, 206, 208, 208, 208, 209);
+//		List list3 = Arrays.asList(204, 109, 105, 103, 203, 210, 105, 202, 209, 201, 206, 205, 107, 202, 102, 104, 108, 107, 202, 108);
+
+		//放跑胡
+//		List list2 = Arrays.asList(101, 101, 102, 103, 105, 105, 105, 106, 108, 109, 109, 203, 203, 205, 205, 206, 208, 208, 210, 210);
+//		List list = Arrays.asList(102, 102, 103, 104, 104, 105, 106, 110, 203, 204, 205, 205, 206, 206, 207, 207, 208, 209, 209, 209);
+//		List list3 = Arrays.asList(102, 208, 201, 110, 202, 209, 202, 201, 108, 104, 107, 101, 109, 204, 204, 106, 210, 108, 103, 104);
+
+//		List list2 = Arrays.asList(101, 101, 102, 103, 105, 105, 105, 106, 108, 109, 109, 203, 203, 205, 205, 206, 208, 208, 210, 210);
+//		List list = Arrays.asList(102, 102, 103, 104, 104, 105, 106, 209, 203, 204, 205, 206, 206, 206, 207, 207, 208, 209, 209, 209);
+//		List list3 = Arrays.asList(102, 208, 201, 110, 202, 209, 202, 201, 108, 104, 107, 101, 109, 204, 204, 106, 210, 108, 103, 104);
+
+		//结算异常
+//		List list2 = Arrays.asList(102, 103, 103, 103, 105, 107, 107, 108, 108, 110, 201, 201, 202, 203, 203, 205, 205, 206, 206, 210);
+//		List list = Arrays.asList(101, 102, 102, 104, 105, 107, 108, 108, 109, 109, 110, 110, 110, 201, 202, 203, 208, 209, 209, 210);
+//		List list3 = Arrays.asList(209, 203, 104, 208, 209, 210, 105, 107, 207, 207, 206, 202, 210, 102, 103, 208, 109, 205, 202, 101);
+
+		//提走算自摸
+//		List list2 = Arrays.asList(102, 103, 103, 104, 105, 106, 106, 107, 107, 107, 110, 202, 203, 204, 204, 205, 206, 209, 210, 210);
+//		List list = Arrays.asList(102, 106, 106, 107, 108, 109, 110, 201, 202, 203, 205, 205, 206, 207, 207, 207, 208, 208, 210, 210);
+//		List list3 = Arrays.asList(105, 101, 207, 201, 103, 203, 101, 103, 110, 201, 206, 109, 202, 209, 109, 104, 205, 108, 209, 101);
+
+//		//小7胡不了
+//		List list2 = Arrays.asList(101, 101, 102, 103, 103, 104, 104, 107, 108, 109, 109, 201, 201, 203, 207, 207, 208, 209, 209, 209);
+//		List list = Arrays.asList(101, 102, 103, 104, 106, 106, 107, 108, 109, 110, 201, 202, 202, 204, 204, 204, 206, 208, 209, 210);
+//		List list3 = Arrays.asList(203, 204, 101, 210, 205, 207, 207, 205, 102, 105, 201, 202, 107, 106, 205, 102, 203, 104, 109, 203);
+		
+		//一块匾
+//		List list2 = Arrays.asList(101, 103, 103, 104, 105, 107, 107, 108, 108, 109, 110, 110, 201, 202, 204, 204, 206, 206, 208, 208);
+//		List list = Arrays.asList(102, 102, 106, 106, 108, 109, 110, 201, 201, 203, 203, 205, 205, 206, 207, 208, 209, 209, 210, 210);
+//		List list3 = Arrays.asList(208, 103, 104, 106, 205, 205, 207, 203, 101, 105, 210, 102, 202, 110, 105, 107, 107, 202, 204, 203);
+
+		//胡不了
+//		List list2 = Arrays.asList(101, 102, 103, 103, 104, 105, 106, 107, 107, 108, 109, 110, 110, 203, 205, 206, 206, 208, 208, 209);
+//		List list = Arrays.asList(101, 101, 102, 105, 105, 105, 108, 109, 109, 110, 201, 202, 202, 202, 203, 204, 204, 206, 207, 210);
+//		List list3 = Arrays.asList(207, 104, 207, 110, 203, 107, 102, 209, 108, 107, 104, 106, 204, 203, 103, 108, 103, 201, 209, 104);
+
+		//小三胡不了
+//		List list2 = Arrays.asList(103, 104, 105, 107, 108, 108, 108, 109, 109, 110, 201, 201, 202, 204, 205, 205, 206, 206, 207, 208);
+//		List list = Arrays.asList(101, 101, 102, 102, 103, 103, 105, 106, 107, 109, 110, 110, 203, 203, 207, 207, 207, 208, 208, 210);
+//		List list3 = Arrays.asList(209, 210, 209, 202, 105, 201, 104, 206, 106, 101, 204, 204, 106, 102, 204, 210, 209, 110, 101, 103);
+
+		//没算胡息
+//		List list2 = Arrays.asList(101, 101, 102, 103, 103, 104, 105, 105, 105, 106, 106, 110, 110, 202, 203, 205, 208, 209, 209, 210);
+//		List list = Arrays.asList(101, 102, 103, 104, 107, 107, 108, 109, 110, 202, 203, 203, 205, 206, 207, 208, 208, 208, 209, 210);
+//		List list3 = Arrays.asList(207, 209, 108, 201, 205, 110, 104, 206, 104, 201, 103, 108, 202, 204, 210, 108, 210, 107, 102, 105);
+
+		//小九胡不了
+//		List list2 = Arrays.asList(101, 102, 103, 103, 104, 104, 105, 106, 107, 108, 201, 202, 203, 204, 204, 206, 208, 210, 210, 210);
+//		List list = Arrays.asList(101, 102, 103, 105, 108, 109, 109, 110, 201, 201, 202, 203, 204, 205, 205, 206, 207, 209, 209, 210);
+//		List list3 = Arrays.asList(107, 107, 207, 209, 203, 205, 110, 204, 107, 104, 103, 110, 202, 106, 109, 208, 105, 203, 206, 104);
+//		//123无胡息
+//		List list2 = Arrays.asList(103, 104, 105, 107, 108, 108, 108, 109, 109, 110, 201, 201, 202, 204, 205, 205, 206, 206, 207, 208);
+//		List list = Arrays.asList(101, 101, 102, 102, 103, 103, 105, 106, 107, 109, 110, 110, 203, 203, 207, 207, 207, 208, 208, 210);
+//		List list3 = Arrays.asList(209, 210, 209, 202, 105, 201, 104, 206, 106, 101, 204, 204, 106, 102, 204, 210, 209, 110, 101, 103);
+
+		//护不了2
+//		List list2 = Arrays.asList(101, 101, 101, 103, 105, 107, 107, 109, 110, 201, 202, 202, 204, 205, 206, 207, 208, 209, 210, 210);
+//		List list = Arrays.asList(102, 102, 104, 104, 106, 106, 108, 108, 109, 109, 109, 201, 203, 204, 204, 205, 206, 207, 208, 210);
+//		List list3 = Arrays.asList(110, 102, 106, 208, 201, 210, 103, 102, 203, 203, 103, 104, 204, 206, 105, 110, 108, 207, 205, 206);
+
+		
+//		List list2 = Arrays.asList(101, 102, 102, 105, 105, 105, 106, 106, 109, 110, 110, 201, 202, 202, 203, 203, 204, 204, 207, 208);
+//		List list = Arrays.asList(101, 101, 103, 104, 105, 106, 108, 109, 201, 202, 203, 204, 205, 205, 206, 207, 207, 209, 210, 210);
+//		List list3 = Arrays.asList(103, 205, 205, 110, 104, 109, 109, 106, 110, 102, 207, 101, 206, 209, 108, 104, 107, 107, 202, 103);
+//
 		
 //		List list2 = Arrays.asList(101, 102, 102, 104, 104, 105, 106, 106, 108, 201, 203, 204, 204, 205, 208, 208, 209, 209, 210, 210);
 //		List list = Arrays.asList(102, 103, 104, 105, 107, 110, 202, 202, 202, 202, 203, 203, 205, 205, 206, 206, 206, 208, 209, 210);

game_zp_fangpaofa/src/main/java/extend/zp/player/rule/RulePaoWin.java

@@ -0,0 +1,184 @@
+package extend.zp.player.rule;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.game.Global;
+import com.game.player.state.PlayerEndState;
+import com.game.player.state.PlayerPauseState;
+import com.game.player.state.PlayerWaitState;
+import com.taurus.core.entity.ITArray;
+import com.taurus.core.entity.TArray;
+import com.taurus.core.util.Logger;
+
+import extend.zp.EXPlayer;
+import extend.zp.OpCard;
+import extend.zp.RuleWeight;
+import extend.zp.player.rulestate.PRDiscardPaoState;
+import extend.zp.player.rulestate.PRDrawPaoState;
+import extend.zp.player.rulestate.PRWinState;
+import extend.zp.player.state.EXPlayerWaitState;
+import extend.zp.room.state.EXRoomDealState;
+import extend.zp.room.state.EXRoomSetpState;
+import extend.zp.tip.IRuleBase;
+import extend.zp.tip.Tip;
+import extend.zp.uitl.CardUtil;
+import extend.zp.uitl.MingtangCheck;
+import extend.zp.uitl.Paixing;
+
+public class RulePaoWin implements IRuleBase {
+	public static final Logger logger = Logger.getLogger(RulePaoWin.class);
+
+	@Override
+	public boolean condition(EXPlayer player) {
+		int eventCard = player.getRoom().checkPaoActiveCard;
+		boolean kanOrWei = true;
+		int huxi = 0;
+
+		//// System.out.println("RuleWin");
+		if (player.isLaoYe) {
+
+			return false;
+		}
+		// 这里检测是否跑
+//		for (OpCard opCard : player.opCardList) {
+//			if (opCard.card1 == eventCard && opCard.type == RuleWeight.TYPE_PAO) {
+//				isPao = true;
+//			}
+//		}
+//		logger.info("isPao:"+isPao);
+//		if(!isPao) {
+//			return true;
+//		}
+		EXPlayer activePlayer = (EXPlayer) player.room.playerMapBySeat.get(player.getRoom().checkPaoActiveSeat);
+
+		if (player.getRoom().roomoutcardlist.size() == 0 && player.seat != activePlayer.seat) {
+			player.getRoom().checkPaoActiveCard = 0;
+			player.getRoom().checkPaoActiveSeat = 0;
+
+			return false;
+		}
+		if (activePlayer == null) {
+			player.getRoom().checkPaoActiveCard = 0;
+			player.getRoom().checkPaoActiveSeat = 0;
+
+			return false;
+		}
+
+//		logger.info("如果来到这里看看当前胡牌的手牌" + player.cardInhand);
+		boolean isWin = Paixing.checkWin(player, 0);
+//		logger.info("跑后的结果-------------" + activePlayer);
+//		logger.info("跑后的结果-------------" + player.cardInhand);
+//		logger.info("跑后的结果-------------" + player.opCard);
+//		logger.info("跑后的结果-------------" + isWin);
+//		logger.info("跑后的结果-------------" + player.huXi);
+
+		if (isWin) {
+			player.stateMachine.changeState(Global.getState(PRWinState.class));
+		} else {
+//			logger.info("如果跑后不能胡牌则进入这里-------------");
+			for (OpCard opCard : player.opCardList) {
+				if (opCard.card1 == eventCard && opCard.type == RuleWeight.TYPE_PAO) {
+					if (kanOrWei) {
+						opCard.type = RuleWeight.TYPE_KAN;
+						opCard.huXi = Paixing.caclHuxi(RuleWeight.TYPE_KAN, eventCard);
+						player.kongCount -= 1;
+
+					} else {
+						opCard.type = RuleWeight.TYPE_WEI;
+						opCard.huXi = Paixing.caclHuxi(RuleWeight.TYPE_WEI, eventCard);
+						player.kongCount -= 1;
+
+					}
+				}
+			}
+			
+
+			isWin = Paixing.checkWin(player, eventCard);
+			player.huXi = huxi;
+
+//			logger.info("回退后结果-------------" + activePlayer);
+//			logger.info("回退后结果-------------" + player.cardInhand);
+//			logger.info("回退后结果-------------" + player.opCard);
+//			logger.info("回退后结果-------------" + isWin);
+//			logger.info("回退后结果-------------" + player.huXi);
+
+			if (isWin) {
+				logger.info("回退后进入这里则表示检测胡-------------");
+				ITArray opcard = TArray.newInstance();
+				opcard.addInt(eventCard);
+				int weight = RuleWeight.WIN3;
+				if (activePlayer.seat != player.seat) {
+					if (player.seat == activePlayer.nextSeat) {
+						weight = RuleWeight.WIN2;
+					} else {
+						weight = RuleWeight.WIN1;
+					}
+				}
+				player.getRoom().isFanPao = true;
+				player.getRoom().winSeat = activePlayer.seat;
+				player.hupai_count = player.hupai_count + 1;
+
+				player.winCard = eventCard;
+				Tip tip = new Tip(eventCard, opcard, 7, this, RuleWeight.TYPE_WIN);
+				player.tipMgr.addTip(tip);
+				player.getRoom().checkPaoActiveCard = 0;
+				player.getRoom().checkPaoActiveSeat = 0;
+				logger.info("回退后胡-------------");
+				activePlayer.stateMachine.changeState(Global.getState(PlayerPauseState.class));
+
+//				activePlayer.stateMachine.changeState(Global.getState(PlayerEndState.class));
+				activePlayer.getRoom().stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+
+//				this.action(player);
+				return true;
+			}
+			else {
+//				if (player.seat == player.getRoom().activeSeat) {
+//					player.cardInhand.remove(eventCard);
+//				}
+
+				
+				for (OpCard opCard : player.opCardList) {
+					if (opCard.card1 == eventCard && opCard.type == RuleWeight.TYPE_KAN) {
+						if (kanOrWei) {
+							opCard.type = RuleWeight.TYPE_PAO;
+							opCard.huXi = Paixing.caclHuxi(RuleWeight.TYPE_PAO, eventCard);
+							player.kongCount += 1;
+							player.huXi +=opCard.huXi;
+
+						} else {
+							opCard.type = RuleWeight.TYPE_PAO;
+							opCard.huXi = Paixing.caclHuxi(RuleWeight.TYPE_PAO, eventCard);
+							player.kongCount += 1;
+							player.huXi +=opCard.huXi;
+
+
+						}
+					}
+				}
+//				isWin = Paixing.checkWin(player, eventCard);
+//				player.huXi = huxi;
+
+
+				logger.info("如果都不行则直接跑牌---------------------"+player.huXi);
+//				player.stateMachine.changeState(Global.getState(PRDiscardPaoState.class));
+//				activePlayer.getRoom().stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+
+				player.getRoom().checkPaoActiveCard = 0;
+				player.getRoom().checkPaoActiveSeat = 0;
+
+			}
+		}
+		player.getRoom().checkPaoActiveCard = 0;
+		player.getRoom().checkPaoActiveSeat = 0;
+
+		return false;
+
+	}
+
+	@Override
+	public void action(EXPlayer player) {
+		player.stateMachine.changeState(Global.getState(PRWinState.class));
+	}
+}

game_zp_fangpaofa/src/main/java/extend/zp/player/rule/RuleWei.java

@@ -14,7 +14,10 @@ public class RuleWei implements IRuleBase {
 	@Override
 	public boolean condition(EXPlayer player) {
 		int eventCard = player.drawCard;
-		EXPlayer activePlayer = (EXPlayer) player.room.playerMapBySeat.get(player.room.activeSeat);
+		EXPlayer activePlayer = (EXPlayer) player.getRoom().playerMapBySeat.get(player.getRoom().activeSeat);
+		if(activePlayer==null) {
+			return false;
+		}
 		if (player.getRoom().roomoutcardlist.size()==0&&player.seat!=activePlayer.seat){
 			return false;
 		}

game_zp_fangpaofa/src/main/java/extend/zp/player/rule/RuleWin.java

@@ -24,14 +24,14 @@ public class RuleWin implements IRuleBase {
 
 
 		EXPlayer activePlayer = (EXPlayer) player.room.playerMapBySeat.get(player.room.activeSeat);
-
-		if (player.getRoom().roomoutcardlist.size()==0&&player.seat!=activePlayer.seat){
-			return false;
-		}
 		if (activePlayer == null) {
 			return false;
 		}
 
+		if (player.getRoom().roomoutcardlist.size()==0&&player.seat!=activePlayer.seat){
+			return false;
+		}
+		
 
 		if (Paixing.checkWin(player, activePlayer.drawCard)) {
 			player.guohupao = true;

game_zp_fangpaofa/src/main/java/extend/zp/player/rulestate/PRDiscardPaoState.java

@@ -1,21 +1,31 @@
 package extend.zp.player.rulestate;
 
+import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
 import com.game.Global;
+import com.game.data.Player;
 import com.game.player.state.PlayerWaitState;
 import com.game.state.StateBase;
 import com.taurus.core.entity.ITArray;
 import com.taurus.core.entity.TArray;
+import com.taurus.core.util.Logger;
 import com.taurus.permanent.TPServer;
 
 import extend.zp.*;
+import extend.zp.player.rule.RuleDrawWin;
+import extend.zp.player.state.EXPlayerDisCardTipState;
 import extend.zp.player.state.EXPlayerDiscardState;
+import extend.zp.player.state.EXPlayerDrawTipState;
+import extend.zp.player.state.EXPlayerTipState;
 import extend.zp.room.state.EXRoomSetpState;
+import extend.zp.tip.Tip;
 import extend.zp.uitl.Paixing;
-
+import extend.zp.uitl.WinCard;
 
 public class PRDiscardPaoState extends StateBase<EXPlayer> {
+	public static final Logger logger = Logger.getLogger(PRDiscardPaoState.class);
+
 	@Override
 	public void enter(EXPlayer owner) {
 		owner.kongCount++;
@@ -25,12 +35,17 @@ public class PRDiscardPaoState extends StateBase<EXPlayer> {
 		activePlayer.stateMachine.changeState(Global.getState(PlayerWaitState.class));
 
 		int fromseat = activePlayer.seat;
-		if (!owner.getRoom().isFanPao){
+		if (!owner.getRoom().isFanPao) {
 			EXMainServer.gameCtr.changeActiveSeat(room, owner.seat);
 		}
 
+		int card = owner.getRoom().activeCard;
+		if (card == 0) {
+			card = owner.opCard.getInt(0);
+			owner.getRoom().checkPaoActiveCard = card;
+			owner.getRoom().checkPaoActiveSeat = activePlayer.seat;
 
-		int card = owner.opCard.getInt(0);
+		}
 		int[] paoGroup = new int[4];
 		paoGroup[0] = card;
 		paoGroup[1] = card;
@@ -38,36 +53,72 @@ public class PRDiscardPaoState extends StateBase<EXPlayer> {
 		paoGroup[3] = card;
 
 		owner.paoGroup.add(paoGroup);
-		owner.opCardList.add(new OpCard(RuleWeight.TYPE_PAO, card, card, card, Paixing.caclHuxi(RuleWeight.TYPE_PAO, card)));
+		owner.opCardList
+				.add(new OpCard(RuleWeight.TYPE_PAO, card, card, card, Paixing.caclHuxi(RuleWeight.TYPE_PAO, card)));
 
-		room.activeCard = 0;
-		room.lastDiscardSeat = 0;
 		ITArray opcard = TArray.newInstance();
 		opcard.addInt(card);
 		opcard.addInt(card);
 		opcard.addInt(card);
 		owner.paopai_count = owner.paopai_count + 1;
-		EXMainServer.gameCtr.actionCard(owner, card, card, RuleWeight.TYPE_PAO, fromseat, opcard);
+		if(!owner.getRoom().broadCard.contains(card)) {
+			owner.getRoom().broadCard.add(card);
+			EXMainServer.gameCtr.actionCard(owner, card, card, RuleWeight.TYPE_PAO, fromseat, opcard);
+		}else {
+			logger.info("已经广播过放跑的牌" + card);
+
+		}
+		logger.info(Paixing.checkWin(owner, card));
+		logger.info(owner.playerid != activePlayer.playerid);
+		logger.info(owner.paoqiflag == true);
+
+		if (Paixing.checkWin(owner, 0) && owner.playerid != activePlayer.playerid && owner.paoqiflag == true
+				&& owner.huXi >= 15) {
+			owner.winCard = card;
+			owner.getRoom().isFanPao = true;
+			room.activeCard = 0;
+
+			owner.stateMachine.changeState(Global.getState(PRWinState.class));
+		} else {
+
+			this.toNextState(owner);
+
+		}
+		room.activeCard = 0;
+		room.lastDiscardSeat = 0;
 
-		this.toNextState(owner);
 	}
 
 	@Override
 	public void toNextState(EXPlayer owner) {
-		owner.isTingHu = false;
+//		owner.isTingHu = false;
 		int count = owner.tiCount + owner.kongCount;
+		logger.info("跑牌次数count:" + count);
+		logger.info("跑牌次数count:" + owner.playerid);
 
 		if (count == 1) {
-			//EXMainServer.playerRuleMgr.condition(PlayerRuleManager.HU_RULE, owner);
+			// EXMainServer.playerRuleMgr.condition(PlayerRuleManager.HU_RULE, owner);
 			owner.stateMachine.changeState(Global.getState(EXPlayerDiscardState.class));
 		} else if (count == 2) {
-			//if (owner.tiCount == 2) {
+			// if (owner.tiCount == 2) {
-				//重跑
+			// 重跑
-			//				//owner.stateMachine.changeState(Global.getState(EXPlayerDiscardState.class));
+			// //owner.stateMachine.changeState(Global.getState(EXPlayerDiscardState.class));
-			//} else {
+			// } else {
 			timer(owner);
-			//}
+//			if(owner.seat==owner.room.activeSeat) {
+//				owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
+//				owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+//
+//			}
+
+			// }
 		} else {
+//			if(owner.seat==owner.room.activeSeat) {
+//				owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
+//				owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+//
+//			}
+
 			timer(owner);
 		}
 	}
@@ -81,8 +132,12 @@ public class PRDiscardPaoState extends StateBase<EXPlayer> {
 				owner.room.enqueueRunnable(new Runnable() {
 					@Override
 					public void run() {
-						owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
+						if(owner.seat==owner.room.activeSeat) {
-						owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+							owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
+							owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+
+						}
+						
 					}
 				});
 			}

game_zp_fangpaofa/src/main/java/extend/zp/player/rulestate/PRDrawPaoState.java

@@ -7,6 +7,7 @@ import com.game.player.state.PlayerWaitState;
 import com.game.state.StateBase;
 import com.taurus.core.entity.ITArray;
 import com.taurus.core.entity.TArray;
+import com.taurus.core.util.Logger;
 import com.taurus.permanent.TPServer;
 
 import extend.zp.EXMainServer;
@@ -21,6 +22,8 @@ import extend.zp.uitl.Paixing;
 
 
 public class PRDrawPaoState extends StateBase<EXPlayer> {
+	public static final Logger logger = Logger.getLogger(PRDrawPaoState.class);
+
 	@Override
 	public void enter(EXPlayer owner) {
 
@@ -50,6 +53,14 @@ public class PRDrawPaoState extends StateBase<EXPlayer> {
 
 		EXMainServer.gameCtr.actionCard(owner, card, card, RuleWeight.TYPE_PAO, fromseat, opcard);
 		owner.getRoom().activeCard=0;
+//		logger.info("摸牌来到跑最后----"+owner.getRoom().activeCard);
+//		if (Paixing.checkWin(owner, 0)&& owner.playerid!=activePlayer.playerid && owner.guohupao==true) {
+//			owner.winCard = card;
+//			owner.getRoom().isFanPao = true;
+//
+//			owner.stateMachine.changeState(Global.getState(PRWinState.class));
+//		}
+
 		int count = owner.tiCount + owner.kongCount;
 		if (count<2&&!owner.guohupao){
 			EXMainServer.playerRuleMgr.condition(PlayerRuleManager.HU_RULE, owner);
@@ -79,8 +90,17 @@ public class PRDrawPaoState extends StateBase<EXPlayer> {
 		} else if (count == 2) {
 			//二跑 不出牌
 			timer(owner);
+//			logger.info("来到这里自动出牌----"+owner.playerid);
+//			owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
+//			owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+
 		} else {
 			timer(owner);
+//			logger.info("来到这里是干啥的----"+owner.playerid);
+
+//			owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
+//			owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+
 		}
 	}
 

game_zp_fangpaofa/src/main/java/extend/zp/player/rulestate/PRTiState.java

@@ -7,10 +7,12 @@ import com.game.player.state.PlayerWaitState;
 import com.game.state.StateBase;
 import com.taurus.core.entity.ITArray;
 import com.taurus.core.entity.TArray;
+import com.taurus.core.util.Logger;
 import com.taurus.permanent.TPServer;
 
 import extend.zp.EXMainServer;
 import extend.zp.EXPlayer;
+import extend.zp.MingTang;
 import extend.zp.OpCard;
 import extend.zp.PlayerRuleManager;
 import extend.zp.RuleWeight;
@@ -18,8 +20,9 @@ import extend.zp.player.state.EXPlayerDiscardState;
 import extend.zp.room.state.EXRoomSetpState;
 import extend.zp.uitl.Paixing;
 
-
 public class PRTiState extends StateBase<EXPlayer> {
+	public static final Logger logger = Logger.getLogger(PRTiState.class);
+
 	@Override
 	public void enter(EXPlayer owner) {
 		owner.kongCount++;
@@ -31,14 +34,22 @@ public class PRTiState extends StateBase<EXPlayer> {
 		tiGroup[3] = card;
 
 		owner.tiGroup.add(tiGroup);
-		owner.opCardList.add(new OpCard(RuleWeight.TYPE_TI, card, card, card, Paixing.caclHuxi(RuleWeight.TYPE_TI, card)));
+		owner.opCardList
+				.add(new OpCard(RuleWeight.TYPE_TI, card, card, card, Paixing.caclHuxi(RuleWeight.TYPE_TI, card)));
 
 		ITArray opcard = TArray.newInstance();
 		opcard.addInt(card);
 		opcard.addInt(card);
 		opcard.addInt(card);
 		owner.tipai_count = owner.tipai_count + 1;
-		owner.getRoom().activeCard=0;
+		owner.getRoom().activeCard = 0;
+
+//		if (Paixing.checkWin(owner, 0) && owner.isTingHu == true) {
+//			logger.info("胡息："+owner.huXi);
+//			owner.getRoom().winSeat = owner.seat;
+//			owner.stateMachine.changeState(Global.getState(PRWinState.class));
+//		}
+
 		EXMainServer.gameCtr.actionCard(owner, card, card, RuleWeight.TYPE_TI, owner.seat, opcard);
 		EXMainServer.playerRuleMgr.condition(PlayerRuleManager.HU_RULE, owner);
 	}
@@ -57,11 +68,11 @@ public class PRTiState extends StateBase<EXPlayer> {
 		if (count == 1) {
 			owner.stateMachine.changeState(Global.getState(EXPlayerDiscardState.class));
 		} else if (count == 2) {
-			//if (owner.tiCount == 2) {
+			// if (owner.tiCount == 2) {
-			//	owner.stateMachine.changeState(Global.getState(EXPlayerDiscardState.class));
+			// owner.stateMachine.changeState(Global.getState(EXPlayerDiscardState.class));
-			//} else {
+			// } else {
-				timer(owner);
+			timer(owner);
-		//	}
+			// }
 		} else {
 			timer(owner);
 		}
@@ -76,11 +87,14 @@ public class PRTiState extends StateBase<EXPlayer> {
 				owner.room.enqueueRunnable(new Runnable() {
 					@Override
 					public void run() {
-						owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
+						if(owner.seat==owner.room.activeSeat) {
-						owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+							owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
+							owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));
+
+						}
 					}
 				});
 			}
-		}, 2, TimeUnit.SECONDS);
+		}, 1, TimeUnit.SECONDS);
 	}
 }

game_zp_fangpaofa/src/main/java/extend/zp/player/rulestate/PRWeiState.java

@@ -52,7 +52,13 @@ public class PRWeiState extends StateBase<EXPlayer> {
 		ITArray opcard = TArray.newInstance();
 		opcard.addInt(card);
 		opcard.addInt(card);
-		
+		owner.getRoom().activeCard=0;
+
+//		if (Paixing.checkWin(owner, 0) && owner.isTingHu==true ) {
+//			logger.info("这里显示是否自摸："+owner.getRoom().isFanPao);
+//			owner.stateMachine.changeState(Global.getState(PRWinState.class));
+//		}
+
 		EXMainServer.gameCtr.actionCard(owner, card, card, type, owner.seat, opcard);
 		EXMainServer.playerRuleMgr.condition(PlayerRuleManager.HU_RULE, owner);
 	}

game_zp_fangpaofa/src/main/java/extend/zp/player/rulestate/PRWinState.java

@@ -1,18 +1,22 @@
 package extend.zp.player.rulestate;
 
 import com.game.state.StateBase;
+import com.taurus.core.util.Logger;
 
 import extend.zp.EXPlayer;
 import extend.zp.EXRoom;
 
 
 public class PRWinState extends StateBase<EXPlayer> {
+	public static final Logger logger = Logger.getLogger(PRTiState.class);
+
 	@Override
 	public void enter(EXPlayer owner) {
 
 		EXRoom room = owner.getRoom();
 
 		if (!room.isplaying) {
+			logger.info("当前房间状态异常：---"+owner.stateMachine.lastState);
 			owner.stateMachine.curState = owner.stateMachine.lastState;
 			return;
 		}

game_zp_fangpaofa/src/main/java/extend/zp/player/state/EXPlayerDisCardTipState.java

@@ -5,6 +5,7 @@ import java.util.Map.Entry;
 import com.game.ActionEvent;
 import com.taurus.core.entity.ITArray;
 import com.taurus.core.entity.ITObject;
+import com.taurus.core.util.Logger;
 
 import extend.zp.EXActionEvent;
 import extend.zp.EXPlayer;
@@ -13,8 +14,11 @@ import extend.zp.tip.Tip;
 
 
 public class EXPlayerDisCardTipState extends EXPlayerTipState {
+	public static final Logger logger = Logger.getLogger(EXPlayerDisCardTipState.class);
+
 	@Override
 	public void enter(EXPlayer owner) {
+
 		// TODO Auto-generated method stub
 		super.enter(owner);
 		owner.getRoom().tipMap.put(owner.playerid, owner.tipMgr);
@@ -26,6 +30,7 @@ public class EXPlayerDisCardTipState extends EXPlayerTipState {
 		// TODO Auto-generated method stub
 		super.exit(owner);
 		owner.getRoom().tipMap.remove(owner.playerid);
+
 	}
 
 	@Override
@@ -49,7 +54,9 @@ public class EXPlayerDisCardTipState extends EXPlayerTipState {
 				}
 
 			}
+
 			owner.tipMgr.choicAction(id,null);
+
 		}
 	}
 }

game_zp_fangpaofa/src/main/java/extend/zp/player/state/EXPlayerDrawState.java

@@ -6,6 +6,7 @@ import java.util.concurrent.TimeUnit;
 
 import com.game.Global;
 import com.game.data.Player;
+import com.game.player.state.PlayerEndState;
 import com.game.player.state.PlayerPauseState;
 import com.game.player.state.PlayerWaitState;
 import com.game.state.StateBase;
@@ -25,11 +26,22 @@ import extend.zp.room.state.EXRoomSetpState;
 import extend.zp.uitl.CardUtil;
 import extend.zp.uitl.Paixing;
 
-
 public class EXPlayerDrawState extends StateBase<EXPlayer> {
 	Logger logger = Logger.getLogger(getClass());
+
 	@Override
 	public void enter(EXPlayer owner) {
+		if(owner.stateMachine.lastState instanceof PlayerPauseState) {
+			logger.info("状态异常 ：" + owner.stateMachine.lastState);
+			owner.stateMachine.curState=owner.stateMachine.lastState;
+			return;
+		}
+//		logger.info("owner.isTip:"+owner.isTip+"--"+owner.playerid);
+//		if (owner.isTip) {
+//			logger.info("状态异常 ：" + owner.stateMachine.lastState);
+//			owner.stateMachine.curState=owner.stateMachine.lastState;
+//			return;
+//		}
 		EXRoom room = owner.getRoom();
 		if (owner.getRoom().card.getCount() == 0) {
 			owner.getRoom().liuju = true;
@@ -38,226 +50,181 @@ public class EXPlayerDrawState extends StateBase<EXPlayer> {
 			return;
 		}
 		room.isAllPass = false;
+//		room.isFanPao = false;
 		owner.getRoom().tipMap.clear();
 
-			if (owner.seat == room.adminSeat) {
+		if (owner.seat == room.adminSeat) {
-				Global.logger.info("dealcards playerid:" + owner.playerid + " adminseat");
+			Global.logger.info("dealcards playerid:" + owner.playerid + " adminseat");
-				if (room.while_list) {
+			if (room.while_list) {
-					double rand = Math.random() % 100 * 100;
+				double rand = Math.random() % 100 * 100;
+				ArrayList<Integer> tempCardList = new ArrayList<Integer>();
+				int count = 0;
+				do {
+					int drawCard = room.card.popsub();
+
+					boolean flag = false;
+					for (Map.Entry<Integer, Player> entry : room.playerMapBySeat.entrySet()) {
+						Player player = entry.getValue();
+
+						if (!player.is_white) {
+							if (Paixing.checkWin((EXPlayer) player, drawCard)) {
+								flag = true;
+								break;
+							}
+						}
+					}
+
+					if (flag) {
+						if (rand > room.white_value && room.card.cardList.size() != 0 && count++ <= 5) {
+							tempCardList.add(drawCard);
+							Global.logger.info("no white:" + owner.playerid + " to hu:" + drawCard);
+							continue;
+						}
+					}
+
+					owner.drawCard = drawCard;
+					break;
+				} while (true);
+				room.card.cardList.addAll(tempCardList);
+			} else {
+				owner.drawCard = room.card.popsub();
+			}
+		} else {
+			if (room.while_list) {
+				Global.logger.info("dealcards playerid:" + owner.playerid + " xingyuhao:" + owner.is_white
+						+ " white_value:" + room.white_value);
+				double rand = Math.random() % 100 * 100;
+				if (rand > room.white_value) {
 					ArrayList<Integer> tempCardList = new ArrayList<Integer>();
 					int count = 0;
 					do {
-						int drawCard = room.card.popsub();
+						int drawCard = room.card.pop();
 
 						boolean flag = false;
 						for (Map.Entry<Integer, Player> entry : room.playerMapBySeat.entrySet()) {
 							Player player = entry.getValue();
 
-							if (!player.is_white) {
+							if (player.playerid != owner.playerid) {
-								if (Paixing.checkWin((EXPlayer) player, drawCard)) {
+								if (player.is_white) {
-									flag = true;
+									if (IsGoodCard2((EXPlayer) player, drawCard)) {
-									break;
+										flag = true;
+										break;
+									}
+								} else {
+									if (IsGoodCard2((EXPlayer) player, drawCard)) {
+										flag = false;
+									}
 								}
 							}
 						}
 
-						if (flag) {
+						if (owner.is_white) {
-							if (rand > room.white_value && room.card.cardList.size() != 0 && count++ <= 5) {
+							if (IsGoodCard((EXPlayer) owner, drawCard)) {
+								flag = true;
+							}
+						} else {
+							if (IsGoodCard((EXPlayer) owner, drawCard)) {
+								flag = false;
+							}
+						}
+
+						if (!flag) {
+							if (room.card.cardList.size() > 0 && count++ <= room.card.cardList.size()) {
 								tempCardList.add(drawCard);
-								Global.logger.info("no white:" + owner.playerid + " to hu:" + drawCard);
+								// Global.logger.info("not good card:" + drawCard + " for white player");
 								continue;
 							}
 						}
 
 						owner.drawCard = drawCard;
 						break;
-					}
+					} while (true);
-					while (true);
 					room.card.cardList.addAll(tempCardList);
 				} else {
-					owner.drawCard = room.card.popsub();
+					owner.drawCard = room.card.pop();
 				}
 			} else {
-				if (room.while_list) {
+				if (owner.black_white_status == 2) {
-					Global.logger.info("dealcards playerid:" + owner.playerid + " xingyuhao:" + owner.is_white + " white_value:" + room.white_value);
+					Global.logger
-					double rand = Math.random() % 100 * 100;
+							.info("dealcards playerid:" + owner.playerid + " white player:" + owner.black_white_rate);
-					if (rand > room.white_value) {
+					/*
-						ArrayList<Integer> tempCardList = new ArrayList<Integer>();
+					 * double rand = Math.random() % 100 * 100; if (rand <= owner.black_white_rate)
-						int count = 0;
+					 * { ArrayList<Integer> tempCardList = new ArrayList<Integer>(); int count = 0;
-						do {
+					 * do { int drawCard = room.card.pop();
-							int drawCard = room.card.pop();
+					 * 
-
+					 * boolean flag = false; if (IsGoodCard((EXPlayer) owner, drawCard)) { flag =
-							boolean flag = false;
+					 * true; }
-							for (Map.Entry<Integer, Player> entry : room.playerMapBySeat.entrySet()) {
+					 * 
-								Player player = entry.getValue();
+					 * if (!flag) { if (room.card.cardList.size() > 0 && count++ <=
-
+					 * room.card.cardList.size()) { tempCardList.add(drawCard);
-								if (player.playerid != owner.playerid) {
+					 * //Global.logger.info("not good card:" + drawCard + " for white player");
-									if (player.is_white) {
+					 * continue; } }
-										if (IsGoodCard2((EXPlayer) player, drawCard)) {
+					 * 
-											flag = true;
+					 * owner.drawCard = drawCard; break; } while (true);
-											break;
+					 * room.card.cardList.addAll(tempCardList); } else { owner.drawCard =
-										}
+					 * room.card.pop(); }
-									} else {
+					 */
-										if (IsGoodCard2((EXPlayer) player, drawCard)) {
+					owner.drawCard = room.card.pop();
-											flag = false;
+				} else if (owner.black_white_status == 1) {
-										}
+					Global.logger
-									}
+							.info("dealcards playerid:" + owner.playerid + " black player:" + owner.black_white_rate);
-								}
+					/*
-							}
+					 * double rand = Math.random() % 100 * 100; if (rand <= owner.black_white_rate)
-
+					 * { ArrayList<Integer> tempCardList = new ArrayList<Integer>(); int count = 0;
-							if (owner.is_white) {
+					 * do { int drawCard = room.card.pop();
-								if (IsGoodCard((EXPlayer) owner, drawCard)) {
+					 * 
-									flag = true;
+					 * boolean flag = false; if (IsGoodCard((EXPlayer) owner, drawCard)) { flag =
-								}
+					 * true; }
-							} else {
+					 * 
-								if (IsGoodCard((EXPlayer) owner, drawCard)) {
+					 * if (flag) { if (room.card.cardList.size() > 0 && count++ <=
-									flag = false;
+					 * room.card.cardList.size()) { tempCardList.add(drawCard);
-								}
+					 * //Global.logger.info("not good card:" + drawCard + " for white player");
-							}
+					 * continue; } }
-
+					 * 
-							if (!flag) {
+					 * owner.drawCard = drawCard; break; } while (true);
-								if (room.card.cardList.size() > 0 && count++ <= room.card.cardList.size()) {
+					 * room.card.cardList.addAll(tempCardList); } else { owner.drawCard =
-									tempCardList.add(drawCard);
+					 * room.card.pop(); }
-									//Global.logger.info("not good card:" + drawCard + " for white player");
+					 */
-									continue;
+					owner.drawCard = room.card.pop();
-								}
-							}
-
-							owner.drawCard = drawCard;
-							break;
-						}
-						while (true);
-						room.card.cardList.addAll(tempCardList);
-					} else {
-						owner.drawCard = room.card.pop();
-					}
 				} else {
-					if (owner.black_white_status == 2) {
+					Global.logger.info("dealcards playerid:" + owner.playerid + " general player");
-						Global.logger.info("dealcards playerid:" + owner.playerid + " white player:" + owner.black_white_rate);
+					/*
-						/*double rand = Math.random() % 100 * 100;
+					 * boolean black_flag = false; for (Map.Entry<Integer, Player> entry :
-						if (rand <= owner.black_white_rate) {
+					 * room.playerMapBySeat.entrySet()) { Player player = entry.getValue();
-							ArrayList<Integer> tempCardList = new ArrayList<Integer>();
+					 * 
-							int count = 0;
+					 * if (player.playerid != owner.playerid) { if (player.black_white_status == 1)
-							do {
+					 * { black_flag = true; } } }
-								int drawCard = room.card.pop();
+					 * 
-
+					 * double rand = Math.random() % 100 * 100; if (black_flag && rand <=
-								boolean flag = false;
+					 * owner.black_white_rate) { ArrayList<Integer> tempCardList = new
-								if (IsGoodCard((EXPlayer) owner, drawCard)) {
+					 * ArrayList<Integer>(); int count = 0; do { int drawCard = room.card.pop();
-									flag = true;
+					 * 
-								}
+					 * boolean flag = false; for (Map.Entry<Integer, Player> entry :
-
+					 * room.playerMapBySeat.entrySet()) { Player player = entry.getValue();
-								if (!flag) {
+					 * 
-									if (room.card.cardList.size() > 0 && count++ <= room.card.cardList.size()) {
+					 * if (player.playerid != owner.playerid) { if (player.black_white_status == 1)
-										tempCardList.add(drawCard);
+					 * { if (IsGoodCard2((EXPlayer) player, drawCard)) { flag = true; break; } } } }
-										//Global.logger.info("not good card:" + drawCard + " for white player");
+					 * 
-										continue;
+					 * if (flag) { if (room.card.cardList.size() > 0 && count++ <=
-									}
+					 * room.card.cardList.size()) { tempCardList.add(drawCard);
-								}
+					 * Global.logger.info("not good card:" + drawCard + " for white player");
-
+					 * continue; } }
-								owner.drawCard = drawCard;
+					 * 
-								break;
+					 * owner.drawCard = drawCard; break; } while (true);
-							}
+					 * room.card.cardList.addAll(tempCardList); } else { owner.drawCard =
-							while (true);
+					 * room.card.pop(); }
-							room.card.cardList.addAll(tempCardList);
+					 */
-						} else {
+					owner.drawCard = room.card.pop();
-							owner.drawCard = room.card.pop();
-						}*/
-						owner.drawCard = room.card.pop();
-					} else if (owner.black_white_status == 1) {
-						Global.logger.info("dealcards playerid:" + owner.playerid + " black player:" + owner.black_white_rate);
-						/*double rand = Math.random() % 100 * 100;
-						if (rand <= owner.black_white_rate) {
-							ArrayList<Integer> tempCardList = new ArrayList<Integer>();
-							int count = 0;
-							do {
-								int drawCard = room.card.pop();
-
-								boolean flag = false;
-								if (IsGoodCard((EXPlayer) owner, drawCard)) {
-									flag = true;
-								}
-
-								if (flag) {
-									if (room.card.cardList.size() > 0 && count++ <= room.card.cardList.size()) {
-										tempCardList.add(drawCard);
-										//Global.logger.info("not good card:" + drawCard + " for white player");
-										continue;
-									}
-								}
-
-								owner.drawCard = drawCard;
-								break;
-							}
-							while (true);
-							room.card.cardList.addAll(tempCardList);
-						} else {
-							owner.drawCard = room.card.pop();
-						}*/
-						owner.drawCard = room.card.pop();
-					} else {
-						Global.logger.info("dealcards playerid:" + owner.playerid + " general player");
-						/*boolean black_flag = false;
-						for (Map.Entry<Integer, Player> entry : room.playerMapBySeat.entrySet()) {
-							Player player = entry.getValue();
-
-							if (player.playerid != owner.playerid) {
-								if (player.black_white_status == 1) {
-									black_flag = true;
-								}
-							}
-						}
-
-						double rand = Math.random() % 100 * 100;
-						if (black_flag && rand <= owner.black_white_rate) {
-							ArrayList<Integer> tempCardList = new ArrayList<Integer>();
-							int count = 0;
-							do {
-								int drawCard = room.card.pop();
-
-								boolean flag = false;
-								for (Map.Entry<Integer, Player> entry : room.playerMapBySeat.entrySet()) {
-									Player player = entry.getValue();
-
-									if (player.playerid != owner.playerid) {
-										if (player.black_white_status == 1) {
-											if (IsGoodCard2((EXPlayer) player, drawCard)) {
-												flag = true;
-												break;
-											}
-										}
-									}
-								}
-
-								if (flag) {
-									if (room.card.cardList.size() > 0 && count++ <= room.card.cardList.size()) {
-										tempCardList.add(drawCard);
-										Global.logger.info("not good card:" + drawCard + " for white player");
-										continue;
-									}
-								}
-
-								owner.drawCard = drawCard;
-								break;
-							}
-							while (true);
-							room.card.cardList.addAll(tempCardList);
-						} else {
-							owner.drawCard = room.card.pop();
-						}
-						 */
-						owner.drawCard = room.card.pop();
-					}
 				}
 			}
-
+		}
-
 
 		room.step++;
 		int tempStep = room.step;
 		// if (owner.seat == 2) {
 		// owner.drawCard = 102;
 		// }
-		//owner.drawCard = room.card.pop();
+		// owner.drawCard = room.card.pop();
 		logger.info("drawCard,player:" + owner + ",card:" + owner.drawCard);
 		room.drawCard = owner.drawCard;
 
@@ -266,21 +233,12 @@ public class EXPlayerDrawState extends StateBase<EXPlayer> {
 
 		int card = owner.drawCard;
 		/*
-		for (int i = 0; i < owner.kanGroup.size(); i++) {
+		 * for (int i = 0; i < owner.kanGroup.size(); i++) { if (owner.drawCard ==
-			if (owner.drawCard == owner.kanGroup.get(i)[0]) {
+		 * owner.kanGroup.get(i)[0]) { card = 0; break; } } for (int i = 0; i <
-				card = 0;
+		 * owner.weiGroup.size(); i++) { if (owner.drawCard == owner.weiGroup.get(i)[0])
-				break;
+		 * { card = 0; break; } } if (CardUtil.cardNum(owner.drawCard, owner.cardInhand)
-			}
+		 * >= 2) { card = 0; }
-		}
+		 */
-		for (int i = 0; i < owner.weiGroup.size(); i++) {
-			if (owner.drawCard == owner.weiGroup.get(i)[0]) {
-				card = 0;
-				break;
-			}
-		}
-		if (CardUtil.cardNum(owner.drawCard, owner.cardInhand) >= 2) {
-			card = 0;
-		}*/
 		ITObject otherParam = new TObject();
 		otherParam.putInt("card", card);
 		otherParam.putInt("seat", owner.room.activeSeat);
@@ -295,13 +253,13 @@ public class EXPlayerDrawState extends StateBase<EXPlayer> {
 
 	private boolean IsGoodCard(EXPlayer player, int drawCard) {
 		if (Paixing.checkWin((EXPlayer) player, drawCard)) {
-		    return true;
+			return true;
 		}
 
 		for (int i = 0; i < player.kanGroup.size(); i++) {
 			if (drawCard == player.kanGroup.get(i)[0]) {
-			    return true;
+				return true;
-            }
+			}
 		}
 
 		for (int i = 0; i < player.weiGroup.size(); i++) {
@@ -310,8 +268,7 @@ public class EXPlayerDrawState extends StateBase<EXPlayer> {
 			}
 		}
 
-		if (CardUtil.cardNum(drawCard, player.cardInhand) >= 2)
+		if (CardUtil.cardNum(drawCard, player.cardInhand) >= 2) {
-		{
 			return true;
 		}
 
@@ -335,8 +292,7 @@ public class EXPlayerDrawState extends StateBase<EXPlayer> {
 			}
 		}
 
-		if (CardUtil.cardNum(drawCard, player.cardInhand) >= 2)
+		if (CardUtil.cardNum(drawCard, player.cardInhand) >= 2) {
-		{
 			return true;
 		}
 
@@ -397,7 +353,7 @@ public class EXPlayerDrawState extends StateBase<EXPlayer> {
 					owner.room.enqueueRunnable(new Runnable() {
 						@Override
 						public void run() {
-							if(owner.drawCard != 0) {
+							if (owner.drawCard != 0 ) {
 								ITObject param = new TObject();
 								param.putInt("card", owner.drawCard);
 								param.putInt("seat", owner.seat);
@@ -405,7 +361,7 @@ public class EXPlayerDrawState extends StateBase<EXPlayer> {
 								owner.outcardList.add(owner.drawCard);
 								owner.getRoom().throwCardsSet.add(owner.drawCard);
 								owner.getRoom().getPlayBack().addThrowCardCommand(owner.seat, owner.drawCard);
-	
+
 								owner.drawCard = 0;
 								owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
 								owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));

game_zp_fangpaofa/src/main/java/extend/zp/player/state/EXPlayerDrawTipState.java

@@ -5,18 +5,23 @@ import java.util.Map.Entry;
 import com.game.ActionEvent;
 import com.taurus.core.entity.ITArray;
 import com.taurus.core.entity.ITObject;
+import com.taurus.core.util.Logger;
 
 import extend.zp.EXActionEvent;
 import extend.zp.EXPlayer;
 import extend.zp.RuleWeight;
+import extend.zp.player.rulestate.PRDiscardPaoState;
 import extend.zp.tip.Tip;
 
 
 public class EXPlayerDrawTipState extends EXPlayerTipState {
+	public static final Logger logger = Logger.getLogger(EXPlayerDrawTipState.class);
+
 	public void enter(EXPlayer owner) {
 		super.enter(owner);
 		////System.out.println("outs DI enter");
 		owner.getRoom().tipMap.put(owner.playerid, owner.tipMgr);
+
 	}
 
 	@Override
@@ -25,6 +30,7 @@ public class EXPlayerDrawTipState extends EXPlayerTipState {
 		super.exit(owner);
 		////System.out.println("outs DI exit");
 		owner.getRoom().tipMap.remove(owner.playerid);
+
 	}
 
 	public void reload(EXPlayer owner) {
@@ -42,6 +48,8 @@ public class EXPlayerDrawTipState extends EXPlayerTipState {
 			int id = netParam.getInt("id");
 			ITArray biid = netParam.containsKey("biid")?netParam.getTArray("biid"):null;
 			owner.tipMgr.doAction(id,biid);
+
+
 		}else if (ActionEvent.EVENT_TIMER_AUTO.equals(cmd)) {
 			int id = owner.tipMgr.getUid();
 			for (Entry<Integer, Tip> entry : owner.tipMgr.tipMap.entrySet()) {
@@ -53,6 +61,7 @@ public class EXPlayerDrawTipState extends EXPlayerTipState {
 
 			}
 			owner.tipMgr.doAction(id,null);
+
 		}
 	}
 }

game_zp_fangpaofa/src/main/java/extend/zp/player/state/EXPlayerPreDrawState.java

@@ -10,6 +10,7 @@ import com.game.player.state.PlayerPauseState;
 import com.game.state.StateBase;
 import com.taurus.core.entity.ITObject;
 import com.taurus.core.entity.TObject;
+import com.taurus.core.util.Logger;
 import com.taurus.permanent.TPServer;
 
 import extend.zp.Config;
@@ -19,10 +20,13 @@ import extend.zp.EXMainServer;
 import extend.zp.EXPlayer;
 import extend.zp.EXRoom;
 import extend.zp.PlayerRuleManager;
+import extend.zp.player.rulestate.PRDiscardPaoState;
 import extend.zp.uitl.Paixing;
 
 
 public class EXPlayerPreDrawState extends StateBase<EXPlayer> {
+	public static final Logger logger = Logger.getLogger(EXPlayerPreDrawState.class);
+
 	@Override
 	public void enter(EXPlayer owner) {
 		EXRoom room = owner.getRoom();

game_zp_fangpaofa/src/main/java/extend/zp/player/state/EXPlayerWaitState.java

@@ -1,15 +1,29 @@
 package extend.zp.player.state;
 
+import com.game.Global;
+import com.game.player.state.PlayerEndState;
+import com.game.player.state.PlayerReadyState;
 import com.game.state.StateBase;
+import com.taurus.core.util.Logger;
 
 import extend.zp.EXActionEvent;
 import extend.zp.EXMainServer;
 import extend.zp.EXPlayer;
 import extend.zp.PlayerRuleManager;
+import extend.zp.player.rulestate.PRTiState;
 
 public class EXPlayerWaitState extends StateBase<EXPlayer> {
+	public static final Logger logger = Logger.getLogger(EXPlayerWaitState.class);
+
 	@Override
 	public void execute(EXPlayer owner, String cmd, int gid, Object param) {
+
+//		if (owner.stateMachine.lastState instanceof PlayerEndState) {
+//			logger.info("又抓到你了-------：" + owner.stateMachine.lastState);
+//			owner.stateMachine.changeState(Global.getState(PlayerReadyState.class));
+//			return;
+//		}
+
 		// TODO Auto-generated method stub
 		switch (cmd) {
 		case EXActionEvent.EVENT_OTHER_DISCARD:

game_zp_fangpaofa/src/main/java/extend/zp/room/state/EXRoomDealState.java

@@ -95,7 +95,7 @@ public class EXRoomDealState extends StateBase<EXRoom> {
 					}
 				});
 			}
-		}, 500, TimeUnit.MILLISECONDS);
+		}, 5000, TimeUnit.MILLISECONDS);
 	}
 
 }

game_zp_fangpaofa/src/main/java/extend/zp/room/state/EXRoomSetpState.java

@@ -2,15 +2,28 @@ package extend.zp.room.state;
 
 import com.game.Global;
 import com.game.data.Player;
+import com.game.player.state.PlayerEndState;
+import com.game.player.state.PlayerReadyState;
+import com.game.room.state.RoomEndState;
 import com.game.state.StateBase;
+import com.taurus.core.util.Logger;
 
 import extend.zp.EXMainServer;
 import extend.zp.EXRoom;
 import extend.zp.player.state.EXPlayerDrawState;
+import extend.zp.player.state.EXPlayerWaitState;
 
 public class EXRoomSetpState extends StateBase<EXRoom> {
+	public static final Logger logger = Logger.getLogger(EXRoomSetpState.class);
+
 	@Override
 	public void enter(EXRoom owner) {
+//		if (owner.stateMachine.lastState instanceof RoomEndState) {
+//			logger.info("又又又又抓到你了-------：" + owner.stateMachine.lastState);
+//			owner.stateMachine.changeState(Global.getState(EXRoomStartGameState.class));
+//			return;
+//		}
+
 		Player player;
 		// TODO Auto-generated method stub
 		if (owner.activeSeat == 0) {

game_zp_fangpaofa/src/main/java/extend/zp/tip/TipManager.java

@@ -11,8 +11,10 @@ import com.taurus.core.entity.ITArray;
 import com.taurus.core.entity.ITObject;
 import com.taurus.core.entity.TArray;
 import com.taurus.core.entity.TObject;
+import com.taurus.core.util.Logger;
 
 import extend.zp.*;
+import extend.zp.player.rule.RuleDiscardPao;
 import extend.zp.player.rulestate.PRDrawPaoState;
 import extend.zp.player.state.EXPlayerDiscardState;
 import extend.zp.room.state.EXRoomSetpState;
@@ -20,6 +22,7 @@ import extend.zp.uitl.CardUtil;
 
 
 public class TipManager {
+	public static final Logger logger = Logger.getLogger(TipManager.class);
 
 	private int						id		= 0;
 	private int						uid		= 100;
@@ -45,7 +48,9 @@ public class TipManager {
 		return this.uid;
 	}
 	public void choicAction(int id,ITArray biid) {
+
 		if (id == this.uid) {
+
 			//
 			Iterator<Entry<Integer, Tip>> it = this.tipMap.entrySet().iterator();
 			int card = 0;
@@ -101,6 +106,7 @@ public class TipManager {
 			owner.stateMachine.changeState(Global.getState(PlayerWaitState.class));
 			////System.out.println("typesttteee");
 			owner.getRoom().addAction(new Action(tip, owner));
+
 		} else {
 			//异常下轮
 			//owner.room.stateMachine.changeState(Global.getState(EXRoomSetpState.class));

game_zp_fangpaofa/src/main/java/extend/zp/uitl/MingtangCheck.java

@@ -0,0 +1,968 @@
+package extend.zp.uitl;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
+
+import com.game.data.Room;
+import com.taurus.core.entity.ITObject;
+import com.taurus.core.entity.TObject;
+import com.taurus.core.util.Logger;
+
+import extend.zp.EXPlayer;
+import extend.zp.EXRoom;
+import extend.zp.OpCard;
+import extend.zp.RuleWeight;
+
+public class MingtangCheck {
+	public static final Logger logger = Logger.getLogger(MingtangCheck.class);
+	public List<Integer> cardGroup = new ArrayList<Integer>();
+	public List<Integer> cardList = new ArrayList<Integer>();
+	public Stack<List<Integer>> stack = new Stack<List<Integer>>();
+	public Stack<Integer> stackHuxi = new Stack<Integer>();
+	public List<OpCard> opCardList = new ArrayList<OpCard>();
+	public int pair_count;
+
+	public int huxiTotal;
+
+	public int activeCard;
+
+	public List<Integer> huxiList = new ArrayList<Integer>();
+
+	public MingtangCheck(List<Integer> cardInhand, int addCard) {
+		this.pair_count = 0;
+		this.huxiTotal = 0;
+		this.activeCard = 0;
+		this.huxiList.clear();
+		this.opCardList.clear();
+		this.cardGroup.clear();
+
+		for (int i = 0; i < cardInhand.size(); i++) {
+			this.cardList.add(cardInhand.get(i));
+		}
+		this.cardList.add(Integer.valueOf(addCard));
+		Collections.sort(this.cardList);
+
+	}
+
+	public boolean yikuaibian(EXPlayer player) {
+		this.opCardList.clear();
+
+		int yikuaibianCount = 0;
+		for (int i = 0; i < player.opCardList.size(); i++) {
+			OpCard opCard = player.opCardList.get(i);
+			if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)
+					&& CardUtil.isRedCard(opCard.card3)) {
+				yikuaibianCount++;
+			} else if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)) {
+				yikuaibianCount++;
+			}
+			huxiTotal += opCard.huXi;
+		}
+		// 如果吃碰跑提中的一块扁大于1则返回
+		if (yikuaibianCount > 1) {
+			return false;
+		}
+		int redCardCount = 0;
+		for (int i = 0; i < this.cardList.size(); i++) {
+			if (CardUtil.isRedCard(cardList.get(i))) {
+				redCardCount++;
+			}
+		}
+
+		// 如果红牌数量超过4则返回
+		if (redCardCount > 4) {
+			return false;
+		}
+
+		// 检测各种一块匾排列后能否胡牌
+		int huxi = 0;
+		for (int i = 0; i < this.cardList.size(); i++) {
+			if (CardUtil.isRedCard(cardList.get(i))) {
+				int activeCard = cardList.get(i);
+				if (activeCard % 100 == 2 || activeCard % 100 == 7 || activeCard % 100 == 10) {
+					if (CardUtil.cardNum(activeCard, this.cardList) >= 3) {
+						CardUtil.removeCard(this.cardList, activeCard, 3);
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard));
+						int huXi = 0;
+						if (player.getRoom() == null) {
+							if (activeCard > 200) {
+								huXi = Paixing.caclHuxi(3, activeCard);
+
+							} else {
+								huXi = Paixing.caclHuxi(2, activeCard);
+							}
+						} else {
+							if ((player.getRoom()).isTianHu && activeCard == (player.getRoom()).drawCard
+									&& (player.getRoom()).bankerSeat == player.seat) {
+								huXi = Paixing.caclHuxi(3, activeCard);
+							} else {
+								huXi = Paixing.caclHuxi(2, activeCard);
+							}
+						}
+						opCardList.add(new OpCard(RuleWeight.TYPE_PONG, activeCard, activeCard, activeCard, huXi));
+
+						huxiTotal += huXi;
+
+						if (tryWin(player, pair_count)) {
+							for (int j = 0; j < opCardList.size(); j++) {
+								OpCard opCard = opCardList.get(j);
+								if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)
+										&& CardUtil.isRedCard(opCard.card3)) {
+									yikuaibianCount++;
+								} else if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)) {
+									yikuaibianCount++;
+								}
+							}
+							// 如果吃碰跑提中的一块扁大于1则返回
+							if (yikuaibianCount > 1) {
+								return false;
+							}
+							return true;
+						}
+
+					}
+				}
+				if (activeCard % 100 == 2) {
+
+					// 组装二贰贰
+					if (CardUtil.cardNum(activeCard, this.cardList) >= 1
+							&& CardUtil.cardNum(activeCard + 100, this.cardList) >= 2) {
+						CardUtil.removeCard(this.cardList, activeCard, 1);
+						CardUtil.removeCard(this.cardList, activeCard + 100, 2);
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						ITObject obj = TObject.newInstance();
+						obj.putInt("type", RuleWeight.CHOW1);
+						obj.putInt("hu_xi", 0);
+						obj.putInt("card1", activeCard);
+						obj.putInt("card2", activeCard + 100);
+						obj.putInt("card3", activeCard + 100);
+
+						opCardList.add(new OpCard(RuleWeight.TYPE_CHOW_OTHER, activeCard, activeCard + 100,
+								activeCard + 100, 0));
+
+						if (tryWin(player, pair_count)) {
+							for (int j = 0; j < opCardList.size(); j++) {
+								OpCard opCard = opCardList.get(j);
+								if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)
+										&& CardUtil.isRedCard(opCard.card3)) {
+									yikuaibianCount++;
+								} else if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)) {
+									yikuaibianCount++;
+								}
+							}
+							// 如果吃碰跑提中的一块扁大于1则返回
+							if (yikuaibianCount > 1) {
+								return false;
+							}
+							return true;
+						}
+					}
+					// 组装二二贰
+					if (CardUtil.cardNum(activeCard, this.cardList) >= 2
+							&& CardUtil.cardNum(activeCard + 100, this.cardList) >= 1) {
+						CardUtil.removeCard(this.cardList, activeCard, 2);
+						CardUtil.removeCard(this.cardList, activeCard + 100, 1);
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						opCardList.add(new OpCard(RuleWeight.TYPE_CHOW_OTHER, activeCard, activeCard + 100,
+								activeCard + 100, 0));
+
+						if (tryWin(player, pair_count)) {
+							for (int j = 0; j < opCardList.size(); j++) {
+								OpCard opCard = opCardList.get(j);
+								if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)
+										&& CardUtil.isRedCard(opCard.card3)) {
+									yikuaibianCount++;
+								} else if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)) {
+									yikuaibianCount++;
+								}
+							}
+							// 如果吃碰跑提中的一块扁大于1则返回
+							if (yikuaibianCount > 1) {
+								return false;
+							}
+							return true;
+						}
+
+					}
+				}
+				if (activeCard % 100 == 7) {
+					// 组装七柒柒
+					System.out.println(CardUtil.cardNum(activeCard, this.cardList));
+					System.out.println(CardUtil.cardNum(activeCard + 100, this.cardList));
+					if (CardUtil.cardNum(activeCard, this.cardList) >= 1
+							&& CardUtil.cardNum(activeCard + 100, this.cardList) >= 2) {
+						CardUtil.removeCard(this.cardList, activeCard, 1);
+						CardUtil.removeCard(this.cardList, activeCard + 100, 2);
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						opCardList.add(new OpCard(RuleWeight.TYPE_CHOW_OTHER, activeCard, activeCard + 100,
+								activeCard + 100, 0));
+
+						if (tryWin(player, pair_count)) {
+							for (int j = 0; j < opCardList.size(); j++) {
+								OpCard opCard = opCardList.get(j);
+								if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)
+										&& CardUtil.isRedCard(opCard.card3)) {
+									yikuaibianCount++;
+								} else if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)) {
+									yikuaibianCount++;
+								}
+							}
+							// 如果吃碰跑提中的一块扁大于1则返回
+							if (yikuaibianCount > 1) {
+								return false;
+							}
+							return true;
+						}
+
+					}
+
+					// 组装七七柒
+					if (CardUtil.cardNum(activeCard, this.cardList) >= 2
+							&& CardUtil.cardNum(activeCard + 100, this.cardList) >= 1) {
+						CardUtil.removeCard(this.cardList, activeCard, 2);
+						CardUtil.removeCard(this.cardList, activeCard + 100, 1);
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						opCardList.add(
+								new OpCard(RuleWeight.TYPE_CHOW_OTHER, activeCard, activeCard, activeCard + 100, 0));
+
+						if (tryWin(player, player.tiCount + player.kongCount)) {
+							for (int j = 0; j < opCardList.size(); j++) {
+								OpCard opCard = opCardList.get(j);
+								if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)
+										&& CardUtil.isRedCard(opCard.card3)) {
+									yikuaibianCount++;
+								} else if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)) {
+									yikuaibianCount++;
+								}
+							}
+							// 如果吃碰跑提中的一块扁大于1则返回
+							if (yikuaibianCount > 1) {
+								return false;
+							}
+							return true;
+						}
+
+					}
+				}
+				if (activeCard % 100 == 10) {
+					// 组装十拾拾
+					if (CardUtil.cardNum(activeCard, this.cardList) >= 1
+							&& CardUtil.cardNum(activeCard + 100, this.cardList) >= 2) {
+						CardUtil.removeCard(this.cardList, activeCard, 1);
+						CardUtil.removeCard(this.cardList, activeCard + 100, 2);
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						opCardList.add(new OpCard(RuleWeight.TYPE_CHOW_OTHER, activeCard, activeCard + 100,
+								activeCard + 100, 0));
+
+						if (tryWin(player, pair_count)) {
+							for (int j = 0; j < opCardList.size(); j++) {
+								OpCard opCard = opCardList.get(j);
+								if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)
+										&& CardUtil.isRedCard(opCard.card3)) {
+									yikuaibianCount++;
+								} else if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)) {
+									yikuaibianCount++;
+								}
+							}
+							// 如果吃碰跑提中的一块扁大于1则返回
+							if (yikuaibianCount > 1) {
+								return false;
+							}
+							return true;
+						}
+
+					}
+					// 组装十十拾
+					if (CardUtil.cardNum(activeCard, this.cardList) >= 2
+							&& CardUtil.cardNum(activeCard + 100, this.cardList) >= 1) {
+						CardUtil.removeCard(this.cardList, activeCard, 2);
+						CardUtil.removeCard(this.cardList, activeCard + 100, 1);
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard));
+						cardGroup.add(Integer.valueOf(activeCard + 100));
+						opCardList.add(new OpCard(RuleWeight.TYPE_CHOW_OTHER, activeCard, activeCard + 100,
+								activeCard + 100, 0));
+
+						if (tryWin(player, pair_count)) {
+							for (int j = 0; j < opCardList.size(); j++) {
+								OpCard opCard = opCardList.get(j);
+								if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)
+										&& CardUtil.isRedCard(opCard.card3)) {
+									yikuaibianCount++;
+								} else if (CardUtil.isRedCard(opCard.card1) && CardUtil.isRedCard(opCard.card2)) {
+									yikuaibianCount++;
+								}
+							}
+							// 如果吃碰跑提中的一块扁大于1则返回
+							if (yikuaibianCount > 1) {
+								return false;
+							}
+							return true;
+						}
+
+					}
+				}
+			}
+		}
+
+		return false;
+	}
+
+	public boolean tryWin(EXPlayer player, int tikongCount) {
+		if (this.cardList.size() == 0) {
+			if (player.tiCount + player.kongCount > 0) {
+				if (this.pair_count == 1) {
+					return true;
+
+				}
+				return false;
+			}
+			if (this.pair_count > 0) {
+				return false;
+
+			}
+			return true;
+		}
+		int activeCard = 0;
+		for (Iterator<Integer> iterator = this.cardList.iterator(); iterator.hasNext();) {
+			int card = ((Integer) iterator.next()).intValue();
+			if (card == 201 || card == 202) {
+				activeCard = card;
+				break;
+			}
+		}
+		if (activeCard == 0)
+			activeCard = ((Integer) this.cardList.get(0)).intValue();
+		if (activeCard % 100 == 1) {
+			if (tryShunzi1(activeCard, player)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+//				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, card, card + 1, card + 2, huXi));
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
+				if (huXi > 0)
+					huxiTotal -= huXi;
+
+			}
+			if (tryKezi(activeCard, player)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
+				if (huXi > 0)
+					huxiTotal -= huXi;
+			}
+			if (player.tiCount + player.kongCount > 0 && tryPair(activeCard)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				this.pair_count = 0;
+				rollBack();
+				this.stackHuxi.pop();
+			}
+			if (tryShunzi2(activeCard)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+				this.stackHuxi.pop();
+			}
+		} else if (activeCard % 100 == 2) {
+			if (tryShunzi3(activeCard, player)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
+				if (huXi > 0)
+					huxiTotal -= huXi;
+			}
+			if (tryKezi(activeCard, player)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
+				if (huXi > 0)
+					huxiTotal -= huXi;
+			}
+			if (player.tiCount + player.kongCount > 0 && tryPair(activeCard)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				this.pair_count = 0;
+				rollBack();
+				this.stackHuxi.pop();
+			}
+			if (tryShunzi1(activeCard, player)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
+				if (huXi > 0)
+					huxiTotal -= huXi;
+			}
+			if (tryShunzi2(activeCard)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+				this.stackHuxi.pop();
+			}
+		} else {
+			if (tryKezi(activeCard, player)) {
+				boolean canWin = tryWin(player, tikongCount);
+				if (canWin)
+					return true;
+				rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
+				if (huXi > 0)
+					huxiTotal -= huXi;
+			}
+			if (player.tiCount + player.kongCount > 0 && tryPair(activeCard)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				this.pair_count = 0;
+				rollBack();
+				this.stackHuxi.pop();
+			}
+			if (tryShunzi1(activeCard, player)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
+				if (huXi > 0)
+					huxiTotal -= huXi;
+			}
+			if (tryShunzi2(activeCard)) {
+				if (tryWin(player, tikongCount))
+					return true;
+				rollBack();
+				this.stackHuxi.pop();
+			}
+		}
+		return false;
+	}
+
+	boolean tryKezi(int card, EXPlayer player) {
+		if (huxiTotal + player.huXi > 30) {
+			return false;
+		}
+		if (CardUtil.cardNum(card, this.cardList) >= 3) {
+			CardUtil.removeCard(this.cardList, card, CardUtil.cardNum(card, this.cardList));
+			List<Integer> cardGroup = new ArrayList<>();
+			cardGroup.add(Integer.valueOf(card));
+			cardGroup.add(Integer.valueOf(card));
+			cardGroup.add(Integer.valueOf(card));
+			push(cardGroup);
+			int huXi = 0;
+			if (player.getRoom() == null) {
+				if (card > 200) {
+					huXi = Paixing.caclHuxi(2, card);
+
+				} else {
+					huXi = Paixing.caclHuxi(2, card);
+				}
+
+			} else {
+				if ((player.getRoom()).isTianHu && card == (player.getRoom()).drawCard
+						&& (player.getRoom()).bankerSeat == player.seat) {
+					huXi = Paixing.caclHuxi(3, card);
+				} else {
+					huXi = Paixing.caclHuxi(2, card);
+				}
+			}
+			opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, card, card, card, huXi));
+
+			huxiTotal += huXi;
+			this.stackHuxi.push(Integer.valueOf(huXi));
+			return true;
+		}
+		return false;
+	}
+
+	private boolean tryShunzi1(int card, EXPlayer player) {
+
+		if (card < 200 && card % 100 > 8)
+			return false;
+		if (CardUtil.cardNum(card + 1, this.cardList) > 0 && CardUtil.cardNum(card + 2, this.cardList) > 0) {
+			CardUtil.removeCard(this.cardList, card, 1);
+			CardUtil.removeCard(this.cardList, card + 1, 1);
+			CardUtil.removeCard(this.cardList, card + 2, 1);
+
+			List<Integer> cardGroup = new ArrayList<>();
+			cardGroup.add(Integer.valueOf(card));
+			cardGroup.add(Integer.valueOf(card + 1));
+			cardGroup.add(Integer.valueOf(card + 2));
+			push(cardGroup);
+
+			int huXi = 0;
+			if (card % 100 == 1) {
+//				if (huxiTotal + player.huXi >= 30) {
+//					return false;
+//				}
+
+				huXi = Paixing.caclHuxi(14, card);
+				huxiTotal += huXi;
+			}
+			opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, card, card + 1, card + 2, huXi));
+
+			this.stackHuxi.push(Integer.valueOf(huXi));
+			return true;
+		}
+		return false;
+	}
+
+	private boolean tryShunzi2(int card) {
+		if (CardUtil.cardType(card) == 1) {
+			if (CardUtil.cardNum(card + 100, this.cardList) >= 1 && CardUtil.cardNum(card, this.cardList) >= 2) {
+				CardUtil.removeCard(this.cardList, card, 2);
+				CardUtil.removeCard(this.cardList, card + 100, 1);
+				List<Integer> cardGroup = new ArrayList<>();
+				cardGroup.add(Integer.valueOf(card));
+				cardGroup.add(Integer.valueOf(card));
+				cardGroup.add(Integer.valueOf(card + 100));
+				push(cardGroup);
+
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, card, card, card + 100, 0));
+
+				this.stackHuxi.push(Integer.valueOf(0));
+				return true;
+			}
+			if (CardUtil.cardNum(card + 100, this.cardList) >= 2) {
+				CardUtil.removeCard(this.cardList, card, 1);
+				CardUtil.removeCard(this.cardList, card + 100, 2);
+				List<Integer> cardGroup = new ArrayList<>();
+				cardGroup.add(Integer.valueOf(card));
+				cardGroup.add(Integer.valueOf(card + 100));
+				cardGroup.add(Integer.valueOf(card + 100));
+				push(cardGroup);
+
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, card, card + 100, card + 100, 0));
+
+				this.stackHuxi.push(Integer.valueOf(0));
+				return true;
+			}
+		} else {
+			if (CardUtil.cardNum(card - 100, this.cardList) >= 1 && CardUtil.cardNum(card, this.cardList) >= 2) {
+				CardUtil.removeCard(this.cardList, card, 1);
+				CardUtil.removeCard(this.cardList, card - 100, 2);
+				List<Integer> cardGroup = new ArrayList<>();
+				cardGroup.add(Integer.valueOf(card));
+				cardGroup.add(Integer.valueOf(card));
+				cardGroup.add(Integer.valueOf(card - 100));
+				push(cardGroup);
+
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, card, card + 1, card + 2, 0));
+
+				this.stackHuxi.push(Integer.valueOf(0));
+				return true;
+			}
+			if (CardUtil.cardNum(card - 100, this.cardList) >= 2) {
+				CardUtil.removeCard(this.cardList, card - 100, 1);
+				CardUtil.removeCard(this.cardList, card, 2);
+				List<Integer> cardGroup = new ArrayList<>();
+				cardGroup.add(Integer.valueOf(card));
+				cardGroup.add(Integer.valueOf(card - 100));
+				cardGroup.add(Integer.valueOf(card - 100));
+				push(cardGroup);
+
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, card - 100, card, card, 0));
+
+				this.stackHuxi.push(Integer.valueOf(0));
+				return true;
+			}
+		}
+		return false;
+	}
+
+	private boolean tryShunzi3(int card, EXPlayer player) {
+		if (card % 100 == 2 && CardUtil.cardNum(card + 5, this.cardList) > 0
+				&& CardUtil.cardNum(card + 8, this.cardList) > 0) {
+			CardUtil.removeCard(this.cardList, card, 1);
+			CardUtil.removeCard(this.cardList, card + 5, 1);
+			CardUtil.removeCard(this.cardList, card + 8, 1);
+			List<Integer> cardGroup = new ArrayList<>();
+			cardGroup.add(Integer.valueOf(card));
+			cardGroup.add(Integer.valueOf(card + 5));
+			cardGroup.add(Integer.valueOf(card + 8));
+			push(cardGroup);
+//			if (huxiTotal + player.huXi > 30) {
+//				return false;
+//			}
+
+			int huXi = Paixing.caclHuxi(14, card);
+			opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, card, card + 5, card + 8, huXi));
+
+			huxiTotal += huXi;
+
+			this.stackHuxi.push(Integer.valueOf(huXi));
+			return true;
+		}
+		return false;
+	}
+
+	private boolean tryPair(int card) {
+		if (this.pair_count > 0)
+			return false;
+		if (CardUtil.cardNum(card, this.cardList) >= 2) {
+			CardUtil.removeCard(this.cardList, card, 2);
+			List<Integer> cardGroup = new ArrayList<>();
+			cardGroup.add(Integer.valueOf(card));
+			cardGroup.add(Integer.valueOf(card));
+			push(cardGroup);
+			opCardList.add(new OpCard(RuleWeight.TYPE_JIANG, card, card, 0, 0));
+
+			System.out.println("移除了将：" + card);
+			this.pair_count = 1;
+			this.stackHuxi.push(Integer.valueOf(0));
+			return true;
+		}
+		return false;
+	}
+
+	private void push(List<Integer> cardGroup) {
+		this.stack.push(cardGroup);
+	}
+
+	private void rollBack() {
+		List<Integer> cardGroup = this.stack.pop();
+		for (Integer card : cardGroup)
+			this.cardList.add(card);
+		Collections.sort(this.cardList);
+		opCardList.remove(opCardList.size() - 1);
+
+	}
+
+	public boolean huka20(EXPlayer player, int tikongCount) {
+		List<Integer> cardList = new ArrayList<Integer>();
+
+		cardList.addAll(this.cardList);
+//		if (this.tryWin(player, pair_count)) {
+//			logger.info("30胡卡------------：" + (player.huXi + huxiTotal));
+//		}
+//		if (player.huXi + huxiTotal < 30) {
+//			return false;
+//		}
+		this.opCardList.clear();
+
+//		this.cardList.addAll(cardList);
+
+//		this.huxiTotal=0;
+//		this.pair_count=0;
+		if (activeCard == 0)
+			activeCard = ((Integer) cardList.get(0)).intValue();
+		for (int i = 0; i < cardList.size(); i++) {
+			this.huxiTotal = 0;
+			this.pair_count = 0;
+			this.opCardList.clear();
+			activeCard = ((Integer) cardList.get(0)).intValue();
+			// 1 1 2
+			if (CardUtil.cardNum(activeCard, this.cardList) >= 1 && CardUtil.cardNum(activeCard + 100, cardList) >= 2) {
+				CardUtil.removeCard(this.cardList, activeCard, 1);
+				CardUtil.removeCard(this.cardList, activeCard + 100, 2);
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, activeCard, activeCard + 100, activeCard + 100, 0));
+				if (tryWin(player, pair_count)) {
+					if (player.huXi + huxiTotal == 20) {
+						return true;
+					}
+				} else {
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard + 100);
+					this.cardList.add(activeCard + 100);
+				}
+
+			}
+			this.huxiTotal = 0;
+			this.pair_count = 0;
+			this.opCardList.clear();
+			activeCard = ((Integer) cardList.get(0)).intValue();
+			// 1 1 2
+			if (CardUtil.cardNum(activeCard, this.cardList) >= 1 && CardUtil.cardNum(activeCard - 100, cardList) >= 2) {
+				CardUtil.removeCard(this.cardList, activeCard, 1);
+				CardUtil.removeCard(this.cardList, activeCard - 100, 2);
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, activeCard, activeCard - 100, activeCard - 100, 0));
+				if (tryWin(player, pair_count)) {
+					if (player.huXi + huxiTotal == 20) {
+						return true;
+					}
+				} else {
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard - 100);
+					this.cardList.add(activeCard - 100);
+
+				}
+
+			}
+
+			this.huxiTotal = 0;
+			this.pair_count = 0;
+			this.opCardList.clear();
+
+			// 1 2 2
+			if (CardUtil.cardNum(activeCard, this.cardList) >= 2
+					&& CardUtil.cardNum(activeCard + 100, this.cardList) >= 1) {
+				CardUtil.removeCard(this.cardList, activeCard, 2);
+				CardUtil.removeCard(this.cardList, activeCard + 100, 1);
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, activeCard, activeCard, activeCard + 100, 0));
+				if (tryWin(player, pair_count)) {
+					if (player.huXi + huxiTotal == 20) {
+						return true;
+					}
+				} else {
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard + 100);
+				}
+			}
+
+			this.huxiTotal = 0;
+			this.pair_count = 0;
+			this.opCardList.clear();
+
+			// 1 2 2
+			if (CardUtil.cardNum(activeCard, this.cardList) >= 2
+					&& CardUtil.cardNum(activeCard - 100, this.cardList) >= 1) {
+				CardUtil.removeCard(this.cardList, activeCard, 2);
+				CardUtil.removeCard(this.cardList, activeCard - 100, 1);
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, activeCard, activeCard, activeCard - 100, 0));
+
+				if (tryWin(player, pair_count)) {
+					if (player.huXi + huxiTotal == 20) {
+						return true;
+					}
+				} else {
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard - 100);
+				}
+
+			}
+
+		}
+
+		return false;
+	}
+
+	public boolean huka30(EXPlayer player, int tikongCount) {
+		List<Integer> cardList = new ArrayList<Integer>();
+
+		cardList.addAll(this.cardList);
+//		if (this.tryWin(player, pair_count)) {
+//			logger.info("30胡卡------------：" + (player.huXi + huxiTotal));
+//		}
+//		if (player.huXi + huxiTotal < 30) {
+//			return false;
+//		}
+		this.opCardList.clear();
+
+//		this.cardList.addAll(cardList);
+
+//		this.huxiTotal=0;
+//		this.pair_count=0;
+		if (activeCard == 0)
+			activeCard = ((Integer) cardList.get(0)).intValue();
+		for (int i = 0; i < cardList.size(); i++) {
+			this.huxiTotal = 0;
+			this.pair_count = 0;
+			this.opCardList.clear();
+			activeCard = ((Integer) cardList.get(0)).intValue();
+			// 1 1 2
+
+			if (CardUtil.cardNum(activeCard, this.cardList) >= 1 && CardUtil.cardNum(activeCard + 100, cardList) >= 2) {
+				CardUtil.removeCard(this.cardList, activeCard, 1);
+				CardUtil.removeCard(this.cardList, activeCard + 100, 2);
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, activeCard, activeCard + 100, activeCard + 100, 0));
+
+				if (tryWin(player, pair_count)) {
+
+					if (player.huXi + huxiTotal == 30) {
+						return true;
+					}
+
+				} else {
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard + 100);
+					this.cardList.add(activeCard + 100);
+				}
+
+			}
+			this.huxiTotal = 0;
+			this.pair_count = 0;
+			this.opCardList.clear();
+			activeCard = ((Integer) cardList.get(0)).intValue();
+			// 1 1 2
+			if (CardUtil.cardNum(activeCard, this.cardList) >= 1 && CardUtil.cardNum(activeCard - 100, cardList) >= 2) {
+				CardUtil.removeCard(this.cardList, activeCard, 1);
+				CardUtil.removeCard(this.cardList, activeCard - 100, 2);
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, activeCard, activeCard - 100, activeCard - 100, 0));
+				if (tryWin(player, pair_count)) {
+					if (player.huXi + huxiTotal == 30) {
+						return true;
+					}
+
+				} else {
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard - 100);
+					this.cardList.add(activeCard - 100);
+				}
+			}
+
+			this.huxiTotal = 0;
+			this.pair_count = 0;
+			this.opCardList.clear();
+			// 1 2 2
+			if (CardUtil.cardNum(activeCard, this.cardList) >= 2
+					&& CardUtil.cardNum(activeCard + 100, this.cardList) >= 1) {
+				CardUtil.removeCard(this.cardList, activeCard, 2);
+				CardUtil.removeCard(this.cardList, activeCard + 100, 1);
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, activeCard, activeCard, activeCard + 100, 0));
+				if (tryWin(player, pair_count)) {
+					if (player.huXi + huxiTotal == 30) {
+						return true;
+					}
+				} else {
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard + 100);
+				}
+			}
+
+			this.huxiTotal = 0;
+			this.pair_count = 0;
+			this.opCardList.clear();
+
+			// 1 2 2
+			if (CardUtil.cardNum(activeCard, this.cardList) >= 2
+					&& CardUtil.cardNum(activeCard - 100, this.cardList) >= 1) {
+				CardUtil.removeCard(this.cardList, activeCard, 2);
+				CardUtil.removeCard(this.cardList, activeCard - 100, 1);
+				opCardList.add(new OpCard(RuleWeight.TYPE_CHOW, activeCard, activeCard, activeCard - 100, 0));
+				if (tryWin(player, pair_count)) {
+					if (player.huXi + huxiTotal == 30) {
+						return true;
+					}
+				} else {
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard);
+					this.cardList.add(activeCard - 100);
+				}
+			}
+		}
+
+		return false;
+	}
+
+	public static void main(String[] args) throws ClassNotFoundException, IOException {
+//		Map<String, String> redis_room_map = new HashMap<>();
+//		redis_room_map.put("id", "749322");
+//		redis_room_map.put("game", "17");
+//		redis_room_map.put("maxPlayers", "2");
+//		redis_room_map.put("players", "[168168,791309]");
+//		redis_room_map.put("group", "532196");
+//		redis_room_map.put("owner", "{user}:123456");
+//		redis_room_map.put("create_time", "1749539730");
+//		redis_room_map.put("options",
+//				"{\"tuoguan_active_time\":0,\"daniao\":2,\"pid\":17,\"shoupai\":0,\"honghu\":true,\"yikuaibian\":true,\"tiandihu\":true,\"isvip\":0,\"mode\":1,\"hpData\":{\"limitloot\":0,\"limitInRoom\":0,\"type\":1,\"times\":3000,\"maxRound\":100,\"xipai_rewardType\":3,\"limitPump\":0,\"limitPlay\":1000,\"robot_room\":0,\"basePump\":0,\"anchou_rewardType\":3,\"tex_times_room\":1000,\"rewards_list\":[{\"UpperLimitReward\":0,\"pumpProportion\":0,\"UpperLimit\":0}]},\"kahu\":true,\"maxRound\":100,\"mingwei\":true,\"hp_no_limit\":0,\"isNonnegative\":1,\"wuhu\":true,\"game_id\":17,\"maxPlayers\":2,\"hunum\":0,\"fengding\":1,\"haidiliao\":false,\"tuoguan\":false,\"isHidden\":0,\"xi_pai\":true,\"yidianhong\":true,\"shisanhong\":true,\"tuoguan_active_timeIndex\":1,\"tuoguan_result_type\":0,\"xi_pai_score\":1000,\"choupai\":0}");
+//		redis_room_map.put("cache_ver", "12345");
+//		redis_room_map.put("times", "100");
+//		redis_room_map.put("pay", "2");
+//		redis_room_map.put("payer", "2");
+//		redis_room_map.put("AA", "1");
+//		redis_room_map.put("agent", "true");
+//		redis_room_map.put("status", "1");
+//		redis_room_map.put("isActive", "true");
+//		redis_room_map.put("opt", "1");
+//		redis_room_map.put("round", "1");
+//		redis_room_map.put("gpid", "17");
+//		redis_room_map.put("open", "0");
+//		redis_room_map.put("kick_time", "30");
+//		redis_room_map.put("seats", "[1,2]");
+//		EXRoom room = new EXRoom("749322", redis_room_map);
+		EXPlayer player = new EXPlayer(168168, null, "ddddddd");
+
+		List<Integer> list = new ArrayList<>();
+		String str = "102, 102, 103, 103, 104, 104, 203, 201, 201, 202, ";
+		for (String card : str.split(", ")) {
+			list.add(Integer.valueOf(Integer.parseInt(card)));
+		}
+		player.cardInhand = list;
+		List<OpCard> op = new ArrayList<>();
+		OpCard opCard = new OpCard(3, 105, 105, 105, 1);
+		op.add(opCard);
+		OpCard opCard1 = new OpCard(7, 208, 208, 208, 12);
+		op.add(opCard1);
+//		OpCard opCard2 = new OpCard(3, 209, 209, 209, 6);
+//		op.add(opCard2);
+		OpCard opCard3 = new OpCard(3, 106, 106, 106, 1);
+		op.add(opCard3);
+
+		int tikongCount = 0;
+		for (int i = 0; i < op.size(); i++) {
+			if (op.get(i).type == 6 || op.get(i).type == 7) {
+				tikongCount += 1;
+			}
+		}
+		player.opCardList.addAll(op);
+		player.tiCount = 0;
+		player.kongCount = 1;
+		int huxiTotal = 0;
+		for (int i = 0; i < player.opCardList.size(); i++) {
+			OpCard opCards = player.opCardList.get(i);
+			huxiTotal += opCards.huXi;
+		}
+		player.huXi = huxiTotal;
+
+		System.out.println("吃碰跑提畏胡息:" + huxiTotal);
+		WinCard win = new WinCard(player.cardInhand, 201);
+		System.out.println("是否能胡:" + win.tryWin(player));
+		System.out.println("正常胡息:" + (player.huXi));
+
+//		MingtangCheck mingtangCheck = new MingtangCheck(list, 201);
+////		 检测是否能胡
+//		boolean iswin = mingtangCheck.tryWin(player, 1);
+//		System.out.println("是否能胡:" + iswin);
+//		System.out.println("正常胡息:" + (mingtangCheck.huxiTotal + huxiTotal));
+
+		// 检测是否一块匾
+//		MingtangCheck mingtangCheck1 = new MingtangCheck(list, 201);
+//		boolean yikuaibian = mingtangCheck1.yikuaibian(player);
+//		System.out.println("一块匾:" + yikuaibian);
+//		System.out.println("一块匾计算增加胡息:" + mingtangCheck1.huxiTotal);
+//		System.out.println("一块匾对应胡息:" + mingtangCheck1.huxiTotal);
+
+		// 检测是否20胡卡
+		MingtangCheck mingtangCheck20 = new MingtangCheck(list, 201);
+		boolean huka20 = mingtangCheck20.huka20(player, 2);
+		System.out.println("20胡卡:" + huka20);
+		System.out.println("20胡卡计算增加胡息:" + mingtangCheck20.huxiTotal);
+
+		System.out.println("20胡卡对应胡息:" + (mingtangCheck20.huxiTotal + huxiTotal));
+
+//		// 检测是否30胡卡
+//		MingtangCheck mingtangCheck30 = new MingtangCheck(list, 101);
+//		boolean huka30 = mingtangCheck30.huka30(player, 1);
+//		System.out.println("30胡卡:" + huka30);
+//		System.out.println("30胡卡计算增加胡息:" + mingtangCheck30.huxiTotal);
+//		System.out.println("30胡卡对应胡息:" + (mingtangCheck30.huxiTotal + huxiTotal));
+//		System.out.println("30胡卡对应胡息:" + (mingtangCheck30.huxiList.toString()));
+//		System.out.println("30胡卡对应op:" + (mingtangCheck30.opCardList.size()));
+//		for(int i=0;i<mingtangCheck30.opCardList.size();i++) {
+//			System.out.println(mingtangCheck30.opCardList.get(i).card1+"-"+mingtangCheck30.opCardList.get(i).card2+"-"+mingtangCheck30.opCardList.get(i).card3);
+//
+//		}
+
+	}
+}

game_zp_fangpaofa/src/main/java/extend/zp/uitl/Paixing.java

@@ -1,5 +1,8 @@
 package extend.zp.uitl;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import com.taurus.core.util.Logger;
 import extend.zp.EXPlayer;
 import extend.zp.EXRoom;
@@ -31,13 +34,101 @@ public class Paixing {
 //		}
 //		logger.info("当前行动的牌:" + room.activeCard);
 //		logger.info("用户的牌:" + player.cardInhand);
+//		logger.info("用户当前胡息:" + player.huXi);
+
 //		if(room.activeCard!=0) {
 //			player.cardInhand.add(room.activeCard);
 //		}
+		// 新增代码1111111111
+		List<Integer> list = new ArrayList<>();
+		for (int card : player.cardInhand) {
+			list.add(card);
+		}
+//
+		// 处理30胡卡
+		MingtangCheck mingtangCheck30 = new MingtangCheck(list, drawCard);
+		for (int i = 0; i < player.opCardList.size(); i++) {
+			OpCard opCards = player.opCardList.get(i);
+			mingtangCheck30.huxiTotal += opCards.huXi;
+		}
+		boolean huka30 = mingtangCheck30.huka30(player, player.tiCount + player.kongCount);
+
+		if (huka30) {
+			logger.info("30胡卡：" + huka30);
+			player.huXi = 30;
+			player.total_huxi = 30;
+
+			player.handCard.clear();
+			player.opCardList.addAll(mingtangCheck30.opCardList);
+			return true;
+		}
+
+		// 处理20胡卡
+		MingtangCheck mingtangCheck20 = new MingtangCheck(list, drawCard);
+		boolean huka20 = mingtangCheck20.huka20(player, player.tiCount + player.kongCount);
+		mingtangCheck20.huxiTotal = 0;
+		for (int i = 0; i < player.opCardList.size(); i++) {
+			OpCard opCards = player.opCardList.get(i);
+//			logger.info("----------计算当前杠碰吃胡息：" + opCards.card1 + "---" + opCards.card2 + "---" + opCards.card3 + "---"
+//					+ opCards.huXi);
+
+			mingtangCheck20.huxiTotal += opCards.huXi;
+		}
+
+		if (huka20 && mingtangCheck20.huxiTotal >= 15) {
+			logger.info("20胡卡：" + huka20);
+			player.huXi = 20;
+			player.total_huxi = 20;
+			player.handCard.clear();
+			player.opCardList.addAll(mingtangCheck20.opCardList);
+//			for (int i = 0; i < mingtangCheck20.opCardList.size(); i++) {
+//				logger.info(mingtangCheck20.opCardList.get(i).card1 + "---" + mingtangCheck20.opCardList.get(i).card2
+//						+ "---" + mingtangCheck20.opCardList.get(i).card3 + "---"
+//						+ mingtangCheck20.opCardList.get(i).huXi);
+//			}
+
+			return true;
+		}
+
+		// 处理一块扁
+		MingtangCheck mingtangCheck1 = new MingtangCheck(list, drawCard);
+//		logger.info("进入一块匾之前");
+//
+//		logger.info("player:"+player.playerid+"---"+player.cardInhand+"--"+player.opCardList.size()+"---摸到的牌："+drawCard);
+//		for (int i = 0; i < player.opCardList.size(); i++) {
+//			logger.info("已存在的opCard："+player.opCardList.get(i).card1 + "---" + player.opCardList.get(i).card2
+//					+ "---" + player.opCardList.get(i).card3 + "---"
+//					+ player.opCardList.get(i).huXi);
+//		}
+//		logger.info("进入一块匾之后");
+
+		boolean yikuaibian = mingtangCheck1.yikuaibian(player);
+		if (yikuaibian && mingtangCheck1.huxiTotal >= 15) {
+//			for (int i = 0; i < mingtangCheck1.opCardList.size(); i++) {
+//				logger.info("检测一块扁增加的opCard:"+mingtangCheck1.opCardList.get(i).card1 + "---" + mingtangCheck1.opCardList.get(i).card2
+//						+ "---" + mingtangCheck1.opCardList.get(i).card3 + "---"
+//						+ mingtangCheck1.opCardList.get(i).huXi);
+//			}
+//
+//			logger.info("一块匾：" + yikuaibian);
+			player.huXi = mingtangCheck1.huxiTotal;
+			player.opCardList.addAll(mingtangCheck1.opCardList);
+			player.handCard.clear();
+			return true;
+		}
+//		logger.info("player.huXi：" + player.huXi);
+//		logger.info("player.cardInhand：" + player.cardInhand);
+//		logger.info("win.cardList：" + win.cardList);
+
 		// 原始算法计算
 		boolean canWin = win.tryWin(player);
+//		logger.info("canWin：" + canWin);
+//		logger.info("isWin：" + isWin);
+//		logger.info("player.huXi：" + player.huXi);
+
 		if (canWin && !isWin) {
 
+			// 新增代码1111111111
 			if (player.huXi >= 15) {
 				isWin = true;
 			}
@@ -132,6 +223,7 @@ public class Paixing {
 			}
 
 		}
+		logger.info("最后胡息：" + player.huXi);
 		return isWin;
 	}
 

game_zp_fangpaofa/src/main/java/extend/zp/uitl/WinCard.java

@@ -1,24 +1,31 @@
 package extend.zp.uitl;
 
-import java.io.IOException;
+import com.game.data.Room;
-import java.util.*;
-
 import com.taurus.core.util.Logger;
-
 import extend.zp.EXPlayer;
 import extend.zp.EXRoom;
 import extend.zp.OpCard;
-import extend.zp.RuleWeight;
+import java.io.IOException;
-import extend.zp.player.rulestate.PRChi;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
 
 public class WinCard {
 	public int pair_count;
+
 	public int long_count;
+
 	public Stack<List<Integer>> stack;
+
 	public Stack<Integer> stackHuxi;
+
 	public List<Integer> cardList;
+
 	public static final Logger logger = Logger.getLogger(WinCard.class);
-	public boolean activeCardIsUse = false;
 
 	private void push(List<Integer> cardGroup) {
 		this.stack.push(cardGroup);
@@ -26,112 +33,103 @@ public class WinCard {
 
 	private void rollBack() {
 		List<Integer> cardGroup = this.stack.pop();
-		for (Integer card : cardGroup) {
+		for (Integer card : cardGroup)
 			this.cardList.add(card);
-		}
 		Collections.sort(this.cardList);
 	}
 
 	boolean tryKezi(int card, EXPlayer player) {
-		if (player.getRoom().activeCard != 0) {
+		if ((player.getRoom()).activeCard != 0)
-			card = player.getRoom().activeCard;
+			card = (player.getRoom()).activeCard;
-		}
-//		logger.info("当前牌数量：" + CardUtil.cardNum(card, this.cardList) + "--" + card);
 		if (CardUtil.cardNum(card, this.cardList) >= 3) {
 			CardUtil.removeCard(this.cardList, card, CardUtil.cardNum(card, this.cardList));
-			List<Integer> cardGroup = new ArrayList<Integer>();
+			List<Integer> cardGroup = new ArrayList<>();
-			cardGroup.add(card);
+			cardGroup.add(Integer.valueOf(card));
-			cardGroup.add(card);
+			cardGroup.add(Integer.valueOf(card));
-			cardGroup.add(card);
+			cardGroup.add(Integer.valueOf(card));
-			this.push(cardGroup);
+			push(cardGroup);
 			int huXi = 0;
-			if (player.getRoom().isTianHu && card == player.getRoom().drawCard
+			if ((player.getRoom()).isTianHu && card == (player.getRoom()).drawCard
-					&& player.getRoom().bankerSeat == player.seat) {
+					&& (player.getRoom()).bankerSeat == player.seat) {
-				huXi = Paixing.caclHuxi(RuleWeight.TYPE_KAN, card);
+				huXi = Paixing.caclHuxi(3, card);
 			} else {
-				huXi = Paixing.caclHuxi(RuleWeight.TYPE_PONG, card);
+				huXi = Paixing.caclHuxi(2, card);
 			}
-//			logger.info("计算胡息：" + huXi + "--" + card);
-
 			player.huXi += huXi;
-			logger.info("总胡息：" + player.huXi);
+			this.stackHuxi.push(Integer.valueOf(huXi));
-
-			this.stackHuxi.push(huXi);
 			return true;
 		}
 		return false;
 	}
 
 	private boolean tryShunzi1(int card, EXPlayer player) {
-		if (card < 200 && card % 100 > 8) {
+		if (card < 200 && card % 100 > 8)
 			return false;
-		}
 		if (CardUtil.cardNum(card + 1, this.cardList) > 0 && CardUtil.cardNum(card + 2, this.cardList) > 0) {
 			CardUtil.removeCard(this.cardList, card, 1);
 			CardUtil.removeCard(this.cardList, card + 1, 1);
 			CardUtil.removeCard(this.cardList, card + 2, 1);
-			List<Integer> cardGroup = new ArrayList<Integer>();
+			List<Integer> cardGroup = new ArrayList<>();
-			cardGroup.add(card);
+			cardGroup.add(Integer.valueOf(card));
-			cardGroup.add(card + 1);
+			cardGroup.add(Integer.valueOf(card + 1));
-			cardGroup.add(card + 2);
+			cardGroup.add(Integer.valueOf(card + 2));
-			this.push(cardGroup);
+			push(cardGroup);
-
 			int huXi = 0;
 			if (card % 100 == 1) {
-				huXi = Paixing.caclHuxi(RuleWeight.TYPE_CHOW, card);
+				huXi = Paixing.caclHuxi(14, card);
 				player.huXi += huXi;
 			}
-			this.stackHuxi.push(huXi);
+			this.stackHuxi.push(Integer.valueOf(huXi));
 			return true;
 		}
 		return false;
 	}
 
 	private boolean tryShunzi2(int card) {
-		if (CardUtil.cardType(card) == RuleWeight.SMALL_CARD) {
+		if (CardUtil.cardType(card) == 1) {
 			if (CardUtil.cardNum(card + 100, this.cardList) >= 1 && CardUtil.cardNum(card, this.cardList) >= 2) {
 				CardUtil.removeCard(this.cardList, card, 2);
 				CardUtil.removeCard(this.cardList, card + 100, 1);
-				List<Integer> cardGroup = new ArrayList<Integer>();
+				List<Integer> cardGroup = new ArrayList<>();
-				cardGroup.add(card);
+				cardGroup.add(Integer.valueOf(card));
-				cardGroup.add(card);
+				cardGroup.add(Integer.valueOf(card));
-				cardGroup.add(card + 100);
+				cardGroup.add(Integer.valueOf(card + 100));
-				this.push(cardGroup);
+				push(cardGroup);
-				this.stackHuxi.push(0);
+				this.stackHuxi.push(Integer.valueOf(0));
 				return true;
 			}
 			if (CardUtil.cardNum(card + 100, this.cardList) >= 2) {
 				CardUtil.removeCard(this.cardList, card, 1);
 				CardUtil.removeCard(this.cardList, card + 100, 2);
-				List<Integer> cardGroup = new ArrayList<Integer>();
+				List<Integer> cardGroup = new ArrayList<>();
-				cardGroup.add(card);
+				cardGroup.add(Integer.valueOf(card));
-				cardGroup.add(card + 100);
+				cardGroup.add(Integer.valueOf(card + 100));
-				cardGroup.add(card + 100);
+				cardGroup.add(Integer.valueOf(card + 100));
-				this.push(cardGroup);
+				push(cardGroup);
-				this.stackHuxi.push(0);
+				this.stackHuxi.push(Integer.valueOf(0));
 				return true;
 			}
 		} else {
 			if (CardUtil.cardNum(card - 100, this.cardList) >= 1 && CardUtil.cardNum(card, this.cardList) >= 2) {
 				CardUtil.removeCard(this.cardList, card, 2);
 				CardUtil.removeCard(this.cardList, card - 100, 1);
-				List<Integer> cardGroup = new ArrayList<Integer>();
+				List<Integer> cardGroup = new ArrayList<>();
-				cardGroup.add(card);
+				cardGroup.add(Integer.valueOf(card));
-				cardGroup.add(card);
+				cardGroup.add(Integer.valueOf(card));
-				cardGroup.add(card - 100);
+				cardGroup.add(Integer.valueOf(card - 100));
-				this.push(cardGroup);
+				push(cardGroup);
-				this.stackHuxi.push(0);
+				this.stackHuxi.push(Integer.valueOf(0));
 				return true;
 			}
 			if (CardUtil.cardNum(card - 100, this.cardList) >= 2) {
 				CardUtil.removeCard(this.cardList, card, 1);
 				CardUtil.removeCard(this.cardList, card - 100, 2);
-				List<Integer> cardGroup = new ArrayList<Integer>();
+				List<Integer> cardGroup = new ArrayList<>();
-				cardGroup.add(card);
+				cardGroup.add(Integer.valueOf(card));
-				cardGroup.add(card - 100);
+				cardGroup.add(Integer.valueOf(card - 100));
-				cardGroup.add(card - 100);
+				cardGroup.add(Integer.valueOf(card - 100));
-				this.push(cardGroup);
+				push(cardGroup);
-				this.stackHuxi.push(0);
+				this.stackHuxi.push(Integer.valueOf(0));
 				return true;
 			}
 		}
@@ -139,225 +137,186 @@ public class WinCard {
 	}
 
 	private boolean tryShunzi3(int card, EXPlayer player) {
-		if (card % 100 == 2) {
+		if (card % 100 == 2 && CardUtil.cardNum(card + 5, this.cardList) > 0
-			if (CardUtil.cardNum(card + 5, this.cardList) > 0 && CardUtil.cardNum(card + 8, this.cardList) > 0) {
+				&& CardUtil.cardNum(card + 8, this.cardList) > 0) {
-				CardUtil.removeCard(this.cardList, card, 1);
+			CardUtil.removeCard(this.cardList, card, 1);
-				CardUtil.removeCard(this.cardList, card + 5, 1);
+			CardUtil.removeCard(this.cardList, card + 5, 1);
-				CardUtil.removeCard(this.cardList, card + 8, 1);
+			CardUtil.removeCard(this.cardList, card + 8, 1);
-				List<Integer> cardGroup = new ArrayList<Integer>();
+			List<Integer> cardGroup = new ArrayList<>();
-				cardGroup.add(card);
+			cardGroup.add(Integer.valueOf(card));
-				cardGroup.add(card + 5);
+			cardGroup.add(Integer.valueOf(card + 5));
-				cardGroup.add(card + 8);
+			cardGroup.add(Integer.valueOf(card + 8));
-				this.push(cardGroup);
+			push(cardGroup);
-
+			int huXi = Paixing.caclHuxi(14, card);
-				int huXi = Paixing.caclHuxi(RuleWeight.TYPE_CHOW, card);
+			player.huXi += huXi;
-				player.huXi += huXi;
+			this.stackHuxi.push(Integer.valueOf(huXi));
-				this.stackHuxi.push(huXi);
+			return true;
-				return true;
-			}
 		}
 		return false;
 	}
 
 	private boolean tryPair(int card) {
-		if (this.pair_count > 0) {
+		if (this.pair_count > 0)
 			return false;
-		}
 		if (CardUtil.cardNum(card, this.cardList) >= 2) {
 			CardUtil.removeCard(this.cardList, card, 2);
-			List<Integer> cardGroup = new ArrayList<Integer>();
+			List<Integer> cardGroup = new ArrayList<>();
-			cardGroup.add(card);
+			cardGroup.add(Integer.valueOf(card));
-			cardGroup.add(card);
+			cardGroup.add(Integer.valueOf(card));
-			this.push(cardGroup);
+			push(cardGroup);
 			this.pair_count = 1;
-			this.stackHuxi.push(0);
+			this.stackHuxi.push(Integer.valueOf(0));
 			return true;
 		}
 		return false;
 	}
 
 	public boolean tryWin(EXPlayer player) {
-
 		if (this.cardList.size() == 0) {
 			if (player.tiCount + player.kongCount > 0) {
 				if (this.pair_count == 1) {
 					return true;
+
 				}
 				return false;
-			} else {
-				if (this.pair_count > 0) {
-					return false;
-				}
-				return true;
 			}
-		}
+			if (this.pair_count > 0) {
+				return false;
 
+			}
+			return true;
+		}
 		int activeCard = 0;
-		for (int card : this.cardList) {
+		for (Iterator<Integer> iterator = this.cardList.iterator(); iterator.hasNext();) {
+			int card = ((Integer) iterator.next()).intValue();
 			if (card == 201 || card == 202) {
 				activeCard = card;
 				break;
 			}
 		}
-		if (activeCardIsUse == false && player.seat!=player.getRoom().activeSeat) {
+		if (activeCard == 0)
-			activeCard = player.getRoom().activeCard;
+			activeCard = ((Integer) this.cardList.get(0)).intValue();
-			activeCardIsUse = true;
-		}
-
-		if (activeCard == 0) {
-			activeCard = this.cardList.get(0);
-		}
 		if (activeCard % 100 == 1) {
 			if (tryShunzi1(activeCard, player)) {
-				if (tryWin(player)) {
+				if (tryWin(player))
 					return true;
-				}
+				rollBack();
-				this.rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
-				int huXi = this.stackHuxi.pop();
+				if (huXi > 0)
-				if (huXi > 0) {
 					player.huXi -= huXi;
-				}
-			}
 
-			if (tryKezi(activeCard, player)) {
-				if (tryWin(player)) {
-					return true;
-				}
-				this.rollBack();
-				int huXi = this.stackHuxi.pop();
-				if (huXi > 0) {
-					player.huXi -= huXi;
-				}
 			}
-			if (player.tiCount + player.kongCount > 0) {
+			if (tryKezi(activeCard, player)) {
-				if (tryPair(activeCard)) {
+				if (tryWin(player))
-					if (tryWin(player)) {
+					return true;
-						return true;
+				rollBack();
-					}
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
-					this.pair_count = 0;
+				if (huXi > 0)
-					this.rollBack();
+					player.huXi -= huXi;
-					this.stackHuxi.pop();
+			}
-				}
+			if (player.tiCount + player.kongCount > 0 && tryPair(activeCard)) {
+				if (tryWin(player))
+					return true;
+				this.pair_count = 0;
+				rollBack();
+				this.stackHuxi.pop();
 			}
 			if (tryShunzi2(activeCard)) {
-				if (tryWin(player)) {
+				if (tryWin(player))
 					return true;
-				}
+				rollBack();
-				this.rollBack();
 				this.stackHuxi.pop();
 			}
 		} else if (activeCard % 100 == 2) {
-//			logger.info("当前剩余牌----"+this.cardList);
-//			logger.info("当前行动的牌----"+activeCard);
-
 			if (tryShunzi3(activeCard, player)) {
-//				logger.info("吃牌后当前剩余牌----"+this.cardList);
+				if (tryWin(player))
-
-				if (tryWin(player)) {
 					return true;
-				}
+				rollBack();
-				this.rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
-				int huXi = this.stackHuxi.pop();
+				if (huXi > 0)
-				if (huXi > 0) {
 					player.huXi -= huXi;
-				}
 			}
 			if (tryKezi(activeCard, player)) {
-				if (tryWin(player)) {
+				if (tryWin(player))
 					return true;
-				}
+				rollBack();
-				this.rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
-				int huXi = this.stackHuxi.pop();
+				if (huXi > 0)
-				if (huXi > 0) {
+
 					player.huXi -= huXi;
-				}
 			}
-			if (player.tiCount + player.kongCount > 0) {
+			if (player.tiCount + player.kongCount > 0 && tryPair(activeCard)) {
-				if (tryPair(activeCard)) {
+				if (tryWin(player))
-					if (tryWin(player)) {
+					return true;
-						return true;
+				this.pair_count = 0;
-					}
+				rollBack();
-					this.pair_count = 0;
+				this.stackHuxi.pop();
-					this.rollBack();
-					this.stackHuxi.pop();
-				}
 			}
 			if (tryShunzi1(activeCard, player)) {
-				if (tryWin(player)) {
+				if (tryWin(player))
 					return true;
-				}
+				rollBack();
-				this.rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
-				int huXi = this.stackHuxi.pop();
+				if (huXi > 0)
-				if (huXi > 0) {
 					player.huXi -= huXi;
-				}
 			}
 			if (tryShunzi2(activeCard)) {
-				if (tryWin(player)) {
+				if (tryWin(player))
 					return true;
-				}
+				rollBack();
-				this.rollBack();
 				this.stackHuxi.pop();
 			}
 		} else {
 			if (tryKezi(activeCard, player)) {
-
 				boolean canWin = tryWin(player);
-				if (canWin) {
+				if (canWin)
 					return true;
-				}
+				rollBack();
-				this.rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
-				int huXi = this.stackHuxi.pop();
+				if (huXi > 0)
-				if (huXi > 0) {
+
 					player.huXi -= huXi;
-				}
+
 			}
-			if (player.tiCount + player.kongCount > 0) {
+			if (player.tiCount + player.kongCount > 0 && tryPair(activeCard)) {
-				if (tryPair(activeCard)) {
+				if (tryWin(player))
-					if (tryWin(player)) {
+					return true;
-						return true;
+				this.pair_count = 0;
-					}
+				rollBack();
-					this.pair_count = 0;
+				this.stackHuxi.pop();
-					this.rollBack();
-					this.stackHuxi.pop();
-				}
 			}
 			if (tryShunzi1(activeCard, player)) {
-				if (tryWin(player)) {
+				if (tryWin(player))
 					return true;
-				}
+				rollBack();
-				this.rollBack();
+				int huXi = ((Integer) this.stackHuxi.pop()).intValue();
-				int huXi = this.stackHuxi.pop();
+				if (huXi > 0)
-				if (huXi > 0) {
+
 					player.huXi -= huXi;
-				}
+
 			}
 			if (tryShunzi2(activeCard)) {
-				if (tryWin(player)) {
+				if (tryWin(player))
 					return true;
-				}
+				rollBack();
-				this.rollBack();
 				this.stackHuxi.pop();
 			}
 		}
-
 		return false;
 	}
 
 	public WinCard(List<Integer> cardInhand, int addCard) {
-		this.stack = new Stack<List<Integer>>();
+		this.stack = new Stack<>();
-		this.stackHuxi = new Stack<Integer>();
+		this.stackHuxi = new Stack<>();
-		this.cardList = new ArrayList<Integer>();
+		this.cardList = new ArrayList<>();
 		this.cardList.addAll(cardInhand);
-		if (addCard > 0) {
+		if (addCard > 0)
-			this.cardList.add(addCard);
+			this.cardList.add(Integer.valueOf(addCard));
-		}
 		Collections.sort(this.cardList);
 	}
 
 	public static void main(String[] args) throws ClassNotFoundException, IOException {
 		Map<String, String> redis_room_map = new HashMap<>();
-
 		redis_room_map.put("id", "749322");
 		redis_room_map.put("game", "17");
 		redis_room_map.put("maxPlayers", "2");
@@ -381,19 +340,14 @@ public class WinCard {
 		redis_room_map.put("open", "0");
 		redis_room_map.put("kick_time", "30");
 		redis_room_map.put("seats", "[1,2]");
-
-		;
 		EXRoom room = new EXRoom("749322", redis_room_map);
-		EXPlayer player = new EXPlayer(168168, room, "ddddddd");
+		EXPlayer player = new EXPlayer(168168, (Room) room, "ddddddd");
-
 		List<Integer> list = new ArrayList<>();
 		String str = "106";
-		for (String card : str.split(", ")) {
+		for (String card : str.split(", "))
-			list.add(Integer.parseInt(card));
+			list.add(Integer.valueOf(Integer.parseInt(card)));
-		}
 		player.cardInhand = list;
-
+		List<OpCard> op = new ArrayList<>();
-		List<OpCard> op = new ArrayList<OpCard>();
 		OpCard opCard = new OpCard(3, 102, 102, 102, 9);
 		op.add(opCard);
 		WinCard win = new WinCard(list, 106);
@@ -402,16 +356,13 @@ public class WinCard {
 
 	int tryKeziBefore(int card, EXPlayer player) {
 		int huXi = 0;
-		if (CardUtil.cardNum(card, this.cardList) >= 3) {
+		if (CardUtil.cardNum(card, this.cardList) >= 3)
-			if (player.getRoom().isTianHu && card == player.getRoom().drawCard
+			if ((player.getRoom()).isTianHu && card == (player.getRoom()).drawCard
-					&& player.getRoom().bankerSeat == player.seat) {
+					&& (player.getRoom()).bankerSeat == player.seat) {
-				huXi = Paixing.caclHuxi(RuleWeight.TYPE_KAN, card);
+				huXi = Paixing.caclHuxi(3, card);
 			} else {
-				huXi = Paixing.caclHuxi(RuleWeight.TYPE_PONG, card);
+				huXi = Paixing.caclHuxi(2, card);
 			}
-		}
 		return huXi;
-
 	}
-
 }

game_zp_yueyangwaihuzi/src/main/java/extend/zp/EXRoom.java

@@ -227,6 +227,7 @@ public class EXRoom extends Room {
 		else
 		{
 			List<IRuleBase> paoList = new ArrayList<IRuleBase>();
+			paoList.add(new RuleWin());
 			EXMainServer.playerRuleMgr.ruleMap.put(PlayerRuleManager.TI_RULE, paoList);
 
 			List<IRuleBase> drawRuleList = new ArrayList<IRuleBase>();