cards.java

变色龙游戏

import java.util.Random;

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;

public class Cards {
	private Image			m_CardBackImg;					//纸牌背面对象
	private CardSprite		m_aCard[];						//纸牌对象
	private CardSprite		m_aPlayerCard[];				//玩家手中的牌
	private CardSprite		m_aComCard[];					//电脑手中的牌
	private CardSprite		m_LastCard;						//桌面上的最后一张牌
	private int			m_nCardNum;						//当前所发的牌数
	
	private int			m_nPlayerScore;					//玩家所得分数
	private int			m_nPlayerDrop;					//玩家所扣牌的数目
	private int			m_nComScore;					//电脑所得分数
	private int			m_nComDrop;						//电脑所扣牌的数目
	
	private Random			m_Random;						//随机数对象
	
	private int			m_nCurPos;						//当前选择的纸牌位置	
	private boolean		m_bComTurn;						//是否轮到电脑出牌
	
	//构造方法
	public Cards(){
		try{
			//创建纸牌对象
	    	Image img = Image.createImage("/demo/card.png");
	    	m_aCard = new CardSprite[52];
	    	for( int n = 0; n < m_aCard.length; n ++ )
    		{//创建纸牌,并给支派赋予初始的类型和面值
    			m_aCard[n] = new CardSprite(img, 13, 24);
    			int type = n / 13;
    			int value = n % 13 + 1;
    			m_aCard[n].setCard(type, value);
    		}
	    	m_aPlayerCard = new CardSprite[5];
	    	m_aComCard = new CardSprite[5];
	    	//创建纸牌背面图像
	    	m_CardBackImg = Image.createImage("/demo/cardback.png");
	    }
	    catch(Exception exception){}
	  
		//创建随机数对象
		m_Random = new Random();	
	}
	//获取电脑的积分
	public int getComScore(){
		return m_nComScore;
	}
	//获取玩家的积分
	public int getPlayerScore(){
		return m_nPlayerScore;
	}
	//重新开始
	public void Reset(){
		//洗牌，即随机交换两张牌
		int i,j;
		int num = 25;
		CardSprite temp;
		for( int n = 0; n < num; n ++ )
		{
			i = Math.abs( m_Random.nextInt() % 52);
			j = Math.abs( m_Random.nextInt() % 52);
			temp = m_aCard[i];
			m_aCard[i]	= m_aCard[j];
			m_aCard[j]	= temp;
		}
		
		m_nCardNum = 0;
		//给电脑和玩家发牌
		for( int n = 0; n < 5; n ++ ){
			m_aPlayerCard[n] = m_aCard[m_nCardNum];
			m_nCardNum ++;
			m_aComCard[n] = m_aCard[m_nCardNum];
			m_nCardNum ++;
		}
		//桌面上的最后一张牌
		m_LastCard = m_aCard[m_nCardNum];
		m_nCardNum ++;
		
		//设置当前玩家选择的位置
		m_nCurPos = 0;
		
		//当前玩家与电脑的得分清0
		m_nPlayerScore = 0;
		m_nComScore = 0;
		
		//当前玩家与电脑的扣牌数清0
		m_nPlayerDrop = 0;
		m_nComDrop = 0;
		
		//首先由玩家出牌
		m_bComTurn = false;
		
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	//处理按键操作
	//返回-1表示玩家输，返回1表示玩家赢，返回0表示继续游戏
	public int Input(int keyStates){
		if( m_bComTurn )
		{//如果论到电脑出牌，先休息500秒
		 //否则图像覆盖得过快，使玩家无法看到上次的出牌
			try{
				Thread.sleep(500);
			}
			catch(InterruptedException ie){
				ie.printStackTrace();
			} 
			ComputerInput();		//电脑自动出牌
			m_bComTurn = false;
			return WinLost();		//检查输赢
		}
		//移动当前的选择位置
		if( ( keyStates & GameCanvas.LEFT_PRESSED ) != 0 )
			m_nCurPos --;
		if( ( keyStates & GameCanvas.RIGHT_PRESSED ) != 0 )
			m_nCurPos ++;
		if( m_nCurPos < 0 )
			m_nCurPos = 0;
		if( m_nCurPos >= 5 )
			m_nCurPos = 4;

		if( ( keyStates & GameCanvas.DOWN_PRESSED ) != 0 )
		{//按下方向键下，扣掉当前选择的牌
			if( !DropCard( m_nCurPos, true ) )
				return 0;
			m_bComTurn = true;
			return WinLost();		//检查输赢
		}
		if( ( keyStates & GameCanvas.FIRE_PRESSED ) != 0 )
		{//按下中心键，如果可以出牌则出牌，不可以则扣牌
			if( ShowCard( m_nCurPos, true ) )
			{//可以出牌
				m_bComTurn = true;
				return WinLost();	//检查输赢
			}
			else if( DropCard( m_nCurPos, true ) )
			{//可以扣牌
				m_bComTurn = true;
				return WinLost();	//检查输赢
			}			
		}
		return 0;
	}
	//显示图像，参数g对应手机屏幕，scrWidth与scrHeight分别是屏幕的宽与高
	public void Paint(Graphics g, int scrWidth, int scrHeight){
		
		int w = m_CardBackImg.getWidth() + 7;
		int x = ( scrWidth - w * 5 ) / 2;
		int y = scrHeight / 2 - 40;
		
		for( int n = 0; n < 5; n ++ )
		{
			//显示电脑的牌
			if( m_aComCard[n] != null )
				g.drawImage(m_CardBackImg, x, y, 0);
			
			//显示玩家的牌
			if( m_aPlayerCard[n] != null ){
				m_aPlayerCard[n].setPosition( x, y + 70);
				m_aPlayerCard[n].paint(g);
			}
			//显示当前选择的位置
			if( n == m_nCurPos ){
				g.drawRect(x - 1, y + 69, m_aCard[0].getWidth() + 2, 
						m_aCard[0].getHeight() + 2);
			}
			x = x + w;
		}
		
		if( m_LastCard != null )
		{//显示桌面上的最后一张牌
			m_LastCard.setRefPixelPosition(scrWidth/2, scrHeight/2);
			m_LastCard.paint(g);
		}	
		x = 5;
		y = 5;
		for( int n = 0; n < m_nComDrop; n ++ )
		{//显示电脑扣的牌
			g.drawImage(m_CardBackImg, x, y, 0);
			y = y + 3;
		}
		x = scrWidth - m_CardBackImg.getWidth() - 5;
		y = 5;
		for( int n = 0; n < m_nPlayerDrop; n ++ )
		{//显示玩家扣的牌
			g.drawImage(m_CardBackImg, x, y, 0);
			y = y + 3;
		}
	}
	//检查输赢，返回-1表示玩家输，返回1表示玩家赢，返回0表示继续游戏
	private int WinLost(){
		if( m_nCardNum < 52 )					//还没发完牌
			return 0;
		for( int n = 0; n < 5; n ++ ){
			if( m_aPlayerCard[n] != null )		//玩家手中还有牌没出
				return 0;
			if( m_aComCard[n] != null )			//电脑手中还有牌没出
				return 0;
		}
		if( m_nPlayerScore > m_nComScore )
			return -1;							//得分少的获胜
		else
			return 1;
	}
	//处理出牌操作，返回true表示出了一张牌，false表示无法出牌
	//参数index是手中牌的索引
	//参数bPlayer为true表示玩家出牌，否则表示电脑出牌
	private boolean ShowCard( int index, boolean bPlayer ){
		if( index < 0 || index >= 5 )
			return false;
		
		CardSprite cards[] = m_aPlayerCard;
		if( !bPlayer )
			cards = m_aComCard;
		
		//检测该位置是否有牌
		if( cards[index] == null )
			return false;
		//检测该位置的牌是否可以出，同花色或同面值的牌才可以出
		if( cards[index].getType() != m_LastCard.getType() ){
			if( cards[index].getValue() != m_LastCard.getValue() )
				return false;
		}
		//出牌
		m_LastCard = cards[index];
		if( m_nCardNum < 52 )
		{//获取新牌，总共52张牌
			cards[index] = m_aCard[m_nCardNum];
			m_nCardNum ++;
		}
		else		//没有新牌
			cards[index] = null;
		
		return true;
	}
	//扣牌操作，返回true表示扣下一张牌，false表示无法扣牌
	//参数index是手中牌的索引
	//参数bPlayer为true表示玩家扣牌，否则表示电脑扣牌
	private boolean DropCard( int index, boolean bPlayer ){
		if( index < 0 || index >= 5 )
			return false;
		
		CardSprite cards[] = m_aPlayerCard;
		if( !bPlayer )
			cards = m_aComCard;
		
		//检测该位置是否有牌
		if( cards[index] == null )
			return false;
		//获得积分
		if( bPlayer ){
			m_nPlayerScore += cards[index].getScore();
			m_nPlayerDrop ++;
		}
		else{
			m_nComScore += cards[index].getScore();
			m_nComDrop ++;
		}
		
		if( m_nCardNum < 52 )
		{//获取新牌，总共52张牌
			cards[index] = m_aCard[m_nCardNum];
			m_nCardNum ++;
		}
		else		//没有新牌
			cards[index] = null;

		return true;
	}
	//电脑自动出牌
	private void ComputerInput(){
		//types存储手中各种花色的牌的总数
		int types[] = new int[CardSprite.CARD_TYPE_NUM];
		for( int n = 0; n < 5; n ++ ){
			if( m_aComCard[n] != null )
			{//如果该位置有牌，则此花色的牌的数量加1
				types[ m_aComCard[n].getType() ] ++;
			}
		}
		
		int index = -1;
		int score = -1;
		int curtype = m_LastCard.getType();
		//检查电脑手中的牌
		for( int n = 0; n < 5; n ++ )
		{
			//如果该位置没有牌，则检测下一张牌
			if( m_aComCard[n] == null )
				continue;
			if( m_aComCard[n].getValue() == m_LastCard.getValue() )
			{//如果，此牌的面值与上次出牌的面值相同
				if( types[ m_aComCard[n].getType() ] >= types[curtype] )
				{//如果手中新花色牌的数量比原来花色的牌的数量多
					//改变以出牌的种类
					index = n;
					curtype = m_aComCard[n].getType();
				}
			}
			if( curtype == m_LastCard.getType() )
			{//如果还没有改变已出牌的种类
				if( m_aComCard[n].getType() == curtype )
				{//如果此牌的类型与已出牌类型相同
					if( m_aComCard[n].getScore() > score )
					{//找面值最大的出
						score = m_aComCard[n].getScore();
						index = n;
					}
				}
			}
		}
		if( index != -1 )
		{//找到了一张可以出的牌
			ShowCard( index, false );
			return;
		}
		
		//没有可出的牌，则扣面值最小的牌
		index = -1;
		score = 100;
		for( int n = 0; n < 5; n ++ )
		{
			//如果该位置没有牌，则检测下一张牌
			if( m_aComCard[n] == null )
				continue;
			if( m_aComCard[n].getScore() < score ){
				index = n;
				score = m_aComCard[n].getScore();
			}
		}
		if( index >= 0 )
		{//有牌可扣
			DropCard( index, false );
		}
	}
}