cardgamecanvas.java

用J2ME开发的卡片游戏

			if (iCardNum > 0) { //还有没有摸掉
				if (iPlayerCardInfo[iPlayerTurn][0] < 5) { //玩家或电脑手中卡片小于5张，则摸牌
					fetchCard(); 
					for (int i = 0; i< iPlayerCardInfo[iPlayerTurn][1]; i++) { //重画玩家或电脑的卡片
						paintSmallCard(iPlayer[iPlayerTurn][i][1]); 
					}
				}
			}		
		}

		iPlayerTurn = (iPlayerTurn + 1) % 4; //轮到下一位
	}
	
	public void clearRect(int x, int y, int width, int height) { //清空相应区域
		grMain.setClip(x, y, width, height);
		grMain.setColor(0x3A6EA5);
		grMain.fillRect(x, y, width, height);
		grMain.setColor(COLOR_BLACK);
		grMain.setClip(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
	}
	
	private class MainTimerTask extends TimerTask { //画打出的卡片线程
		
		public void run () {	
			if (!bFinish) {	 //游戏还没结束
				if (bReady) { //游戏已经准备好开始
					paintFigure(iPlayerTurn, 2); //画出牌时的表情头像
					grMain.setColor(COLOR_WHITE);
					switch (iPlayerTurn) { //画白框表示出牌
						case 0:	
							grMain.drawRect(141, 150, FIGURE_WIDTH, FIGURE_HEIGHT);						
							break;	
						case 1:
							grMain.drawRect(141, 68, FIGURE_WIDTH, FIGURE_HEIGHT);
							break;
						case 2:
							grMain.drawRect(72, 3, FIGURE_WIDTH, FIGURE_HEIGHT);
							break;
						case 3:
							grMain.drawRect(3, 68, FIGURE_WIDTH, FIGURE_HEIGHT);
							break;
					}
					grMain.setColor(COLOR_BLACK);		
					flushGraphics();
				
					if (iPlayerTurn > 0) {	//轮到电脑
						if (iPlayerCardInfo[iPlayerTurn][0] > 0) {//电脑手中还有卡片
							try { //暂停0.5秒出牌
								Thread.sleep(500);
								int iAIChoice = cMainRule.AI(); //判断该处什么牌
								if (iAIChoice >= 0) { //有牌可出，则出牌
									cardPutOut(iAIChoice); 
								}else { //无牌可出，则吃牌
									cMainRule.eatCard();
								}
							}catch (InterruptedException e) { //线程暂停错误处理
								ErrorHandling ehInterruptedException = new ErrorHandling(display, ErrorHandling.INTERRUPTEDERROR);
							}						
						}
						if (iPlayerTurn == 3) { //玩家的上家出完牌，新一轮开始，玩家还没出牌
							bCardOut = false;
						}
 					}	
				}
			}
		}
	}

	private class KeyPressTimerTask extends TimerTask { //响应键盘输入线程
		
		public void run () {
		      int keyState = getKeyStates(); //取得键值		   
		      boolean bSuccess = true;
		      
			  if (bGameOver) { //游戏已结束，则置相应的标志位，停止线程
			  	bFinish = false;
			  	bReady = false;
			  	if ((keyState & FIRE_PRESSED) != 0) { //按确定键
			  		tmMain.cancel();
			    	if (iScore > iHighScore) { //玩家的得分如果高于记录集中的最高分，则把玩家的得分和头像信息写入记录集	
			    		ByteArrayOutputStream baosInfo = new ByteArrayOutputStream();
			    		DataOutputStream dosInfo = new DataOutputStream(baosInfo);			    		
			    		try {
			    			dosInfo.writeInt(iScore);
			    			dosInfo.writeInt(iPlayerFigure[0]);
			    			dosInfo.flush();
			    			dosInfo.close();
			    			byte[] btScore = baosInfo.toByteArray();
							if (rsInfo.getNumRecords() == 0) {
								rsInfo.addRecord(btScore, 0, btScore.length);
							}else {
								rsInfo.setRecord(1, btScore, 0, btScore.length);
							}
			    			rsInfo.closeRecordStore();
			    		}catch (Exception e) { //记录集读写错误处理
			    			ErrorHandling ehRecordSetException = new ErrorHandling(display, ErrorHandling.RECORDSETERROR);
			    			bSuccess = false;
			    		}
			    		if (bSuccess) { //写入成功，则转到高分榜
			    			HighScoreForm frmHighScore = new HighScoreForm(display);
			    			display.setCurrent(frmHighScore);
			    			frmHighScore.init();
			    		}
					}else { //玩家的得分如果低于记录集中的最高分，则返回主选择界面
						MainMenuCanvas cvsMainMenu = new MainMenuCanvas(display);
						display.setCurrent(cvsMainMenu);
						cvsMainMenu.init();
					}			    	
			  	}
			  }
		      
		      if (iPlayerTurn == 0) { //轮到玩家出卡片时检查是否有卡可出
		      	  if (!bCardOut) { //当轮到玩家出牌时检查
		      	  	  boolean bEatCard = true;
			      	  if (iCardOutNum > 0) { //前人已经出过牌      	  	
				      	  for (int i = 0; i < iPlayerCardInfo[0][1]; i++) { //搜索玩家的牌，看是否有牌可出
				      	  	if (cMainRule.compareCard(iPlayerCardOut[iCardOutNum - 1], iPlayer[0][i][1])) {
				      	  		bEatCard = false;
				      	  		break;
				      	  	}
				      	  }
			      	  }else {
			      	  	bEatCard = false;
			      	  }
			      	  
			      	  if (bEatCard) { //无牌可出，则等待0.3秒后吃牌
			      	  	try {
			      	  		Thread.sleep(300);
			      	  	}catch (InterruptedException e) {
			      	  		ErrorHandling ehInterruptedException = new ErrorHandling(display, ErrorHandling.INTERRUPTEDERROR);
			      	  	}
			      	  	cardPushBack(iCardSelected); 
			      	  	cMainRule.eatCard(); //吃牌
			      	  	bEatCard = false;
			      	  	for (int i = 0; i < iPlayerCardInfo[0][1]; i++) { //重画玩家手中的牌
			      	  		paintSmallCard(iPlayer[0][i][1]);
			      	  	}	
			      	  	iCardSelected = 0;
			      	    cardPopUp(iCardSelected);
			      	    paintLargeCard(iCardSelected);
			      	    
						clearRect(POS_CARDOUTX, POS_CARDOUTY, CARD_LARGEWIDTH + 1, CARD_LARGEHEIGHT + 1);
						grMain.setColor(COLOR_BLACK);
						grMain.drawRect(POS_CARDOUTX, POS_CARDOUTY, CARD_LARGEWIDTH, CARD_LARGEHEIGHT);
						tlCardOut.setCell(0, 0, 0);
						lmCard.paint(grMain, 0, 0);
						flushGraphics();			      	    
			      	  }
			      	  bCardOut = true; 
		      	  }
		      	  
                  if (bReady) {		      	
				      if ((keyState & LEFT_PRESSED) != 0) { //按左键选择左边1张卡片
			    		cardPushBack(iCardSelected);
			    		if (iCardSelected == 0) {
			    			iCardSelected = iPlayerCardInfo[0][1] - 1;
			    		}else {
			    			iCardSelected--;
			    		}
			    		cardPopUp(iCardSelected);
			    		paintLargeCard(iCardSelected);
				      }else if ((keyState & RIGHT_PRESSED) != 0) { //按右键选择右边1张卡片
			    		cardPushBack(iCardSelected);
			    		if (iCardSelected == iPlayerCardInfo[0][1] - 1) {
			    			iCardSelected = 0;
			    		}else {
			    			iCardSelected++;
			    		}
			    		cardPopUp(iCardSelected);
			    		paintLargeCard(iCardSelected);
				      }else if (((keyState & FIRE_PRESSED) != 0) || (keyState & UP_PRESSED) != 0) { //按确定键出牌				      
				      	if (!bFinish) { //本局还没结束，可以出牌
				      		if ((iCardOutNum == 0) || 
				      			  cMainRule.compareCard(iPlayerCardOut[iCardOutNum - 1], iPlayer[0][iCardSelected][1])) {
				      			//第一个出牌或者要出的牌符合规则，则可以出牌
					    		iPlayerCardOut[iCardOutNum] = iPlayer[0][iCardSelected][1];
					    		iCardOutNum++; //已经打出的牌加1
				      			
						      	cardPushBack(iCardSelected);
						      	cardPutOut(iCardSelected);
					    		if (iCardSelected == iPlayerCardInfo[0][1]) {
					    			iCardSelected = 0;
					    		}			    		
					    		cardPopUp(iCardSelected);
					    		paintLargeCard(iCardSelected);
					    		return;
				      		}	    		
				      	}
				      }
			      	}
		      }
		      
		      if (bFinish) { //本局已结束
		      	if ((keyState & FIRE_PRESSED) != 0) { //按确定键等待0.5秒后开始新一局
		      		try {
		      			Thread.sleep(500);
		      		}catch (InterruptedException e) { //线程暂停错误处理
		      			ErrorHandling ehInterruptedException = new ErrorHandling(display, ErrorHandling.INTERRUPTEDERROR);
		      		}
		      		startGame(); //开始新一局游戏
		      	}
		      }
		}
	}
	
	public class Rule { //规则类
		public final static int CARD_INIT_NUM = 5; //开始每位玩家手上的牌数
		public final static int CARD_LIMIT = 5 ; //如果还有牌，玩家手中最少有几张牌，不满则补足
		
		public boolean compareCard(int iCard1, int iCard2) { //比较规则
			boolean bResult = false;
			int iCard1Level, iCard1Property, iCard2Level, iCard2Property; 
			
			if (iCard1 == 0) { //前1张牌为空，则后1张牌可出
				return true;
			}
			
			if (iCard2 == 0) { //后1张牌为空，则不可出
				return false;
			}
			
			iCard1Property = (iCard1 - 1) / CARDPRONUM; //取得牌1的属性
			if (iCard1 <= 12) {
				iCard1Level = (iCard1 - 1) % CARDPRONUM; //取得牌1的等级
			}else if (iCard1 == 13) { //取到的卡片是光
				iCard1Property = CARDGUANG;	
				iCard1Level = 0;
			}else { //取到的卡片是暗
				iCard1Property = CARDAN;
				iCard1Level = 0;
			}
			
			iCard2Property = (iCard2 - 1) / CARDPRONUM;	//取得牌2的属性	
			if (iCard2 <= 12) {
				iCard2Level = (iCard2 - 1) % CARDPRONUM; //取得牌2的属性			
			}else if (iCard2 == 13) { //取到的卡片是光
				iCard2Property = CARDGUANG;	
				iCard2Level = 0;
			}else { //取到的卡片是暗
				iCard2Property = CARDAN;
				iCard2Level = 0;
			}		
			
			if ((iCard1Property == CARDGUANG) ||(iCard1Property == CARDAN) 
				 || (iCard2Property == CARDGUANG) ||(iCard2Property == CARDAN)){ //是光或暗牌，则可出
				bResult = true;
			}else {
				if ((iCard1Property == (iCard2Property + 1) % 4) && (iCard2Level >= iCard1Level)) { //属性克制且等级不小于前者，则可出
					bResult = true;
				}else if ((iCard2Property == iCard1Property) && (iCard2Level > iCard1Level)){ //属性相同且等级大于前者，则可出
					bResult = true;
				}
			}			
			return bResult;
		}
		
		public void throwCard() { //抛牌规则
			int i = 0;
			do {
				if (iPlayer[iPlayerTurn][i][0] == 4) { //有相同属性和等级的4张牌，则抛出
					for (int j = i; j < iPlayerCardInfo[iPlayerTurn][1] - 1; j++) { //重新排序手中的牌
						iPlayer[iPlayerTurn][j][0] = iPlayer[iPlayerTurn][j+1][0];
						iPlayer[iPlayerTurn][j][1] = iPlayer[iPlayerTurn][j+1][1];
					}
					iPlayerCardInfo[iPlayerTurn][0] -= 4;
					iPlayerCardInfo[iPlayerTurn][1]--;
					iPlayer[iPlayerTurn][iPlayerCardInfo[iPlayerTurn][1]][0] = 0;
					iPlayer[iPlayerTurn][iPlayerCardInfo[iPlayerTurn][1]][1] = 0;
				}else {
					i++;
				}
			} while (iPlayer[iPlayerTurn][i][0] != 0);
		}
		
		public void eatCard() { //吃牌规则
			for (int i = 0; i < iCardOutNum; i++) {	 	
				for (int j = 0; j < iPlayerCardInfo[iPlayerTurn][1]; j++) {
					if (iPlayerCardOut[i] == iPlayer[iPlayerTurn][j][1]) { //手中已有和要吃的牌相同种类的牌，则使现有种类的牌加1
						iPlayer[iPlayerTurn][j][0]++;
						iPlayerCardOut[i] = 0;
						break;
					}
				}
					
				if (iPlayerCardOut[i] != 0) { //没有相同种类的牌，则牌的种类加1，牌的数量加1
					iPlayer[iPlayerTurn][iPlayerCardInfo[iPlayerTurn][1]][0] = 1;
					iPlayer[iPlayerTurn][iPlayerCardInfo[iPlayerTurn][1]][1] = iPlayerCardOut[i];
					iPlayerCardInfo[iPlayerTurn][1]++;
					iPlayerCardOut[i] = 0;
				}
			}			
			iPlayerCardInfo[iPlayerTurn][0] += iCardOutNum;
			iCardOutNum = 0;
			
			clearRect(POS_CARDOUTX, POS_CARDOUTY, CARD_LARGEWIDTH + 1, CARD_LARGEHEIGHT + 1);
			grMain.setColor(COLOR_BLACK);
			grMain.drawRect(POS_CARDOUTX, POS_CARDOUTY, CARD_LARGEWIDTH, CARD_LARGEHEIGHT);
			flushGraphics();
			
			throwCard();
			
			while ((iPlayerCardInfo[iPlayerTurn][0] < 5) && (iCardNum > 0)) { //有相同种类的4张牌时，抛出
				fetchCard();
				if (iPlayerCardInfo[iPlayerTurn][0] >= 4) {
					throwCard();
				}
			}
			
			if (iPlayerCardInfo[iPlayerTurn][0] == 0) {	//玩家或电脑手中没牌时，则结束
				if (iPlayerTurn == 0) {
					bWin = true;
				}else {
					bWin = false;
				}
				bFinish = true;
				endGame();
			}
			
		}
		
		public int AI() { //电脑AI
			int iResult = -1;
			for (int i = 0; i < iPlayerCardInfo[iPlayerTurn][1]; i++) {
				if (iCardOutNum > 0) { //已有牌打出，则搜索现有的牌，打出符合规则的牌
					if (compareCard(iPlayerCardOut[iCardOutNum - 1], iPlayer[iPlayerTurn][i][1])) {
			    		iPlayerCardOut[iCardOutNum] = iPlayer[iPlayerTurn][i][1];
			    		iCardOutNum++;
			    		iResult = i;
			    		break;
					}
				}else { //无牌打出，则出第一张牌
					iPlayerCardOut[iCardOutNum] = iPlayer[iPlayerTurn][0][1];
					iCardOutNum++;
					iResult = 0;
					break;
				}
			}
			return iResult;
		}		
	}	
}