handbone.java

移动平台游戏开发

		int index2 = m_aPengIndex[1];
		
		m_aPengBone[m_nPeng] = bone;
		m_aPengBone[m_nPeng+1] = m_aHandBone[index1];
		m_aPengBone[m_nPeng+2] = m_aHandBone[index2];
		m_nPeng += 3;
		//将手中碰掉的拍去掉
		int num = 0;
		for( int n = 0; n < m_nHand; n ++ )
		{
			if( n == index1 || n == index2 )
				continue;
			m_aHandBone[num] = m_aHandBone[n];
			num ++;
		}
		m_nHand = m_nHand - 3; 
		m_nSelectIndex = m_nHand;
		m_HoldBone = m_aHandBone[m_nHand];
		return true;
	}	
	
	//显示图像，参数g对应手机屏幕
	//参数bChi为true表示当前正在选择吃牌的方法
	//（如是三万、四万吃五万，还是用四万、六万吃五万）
	//参数bSelect为true表示当前正在选择要打出的牌
	//参数scrWidth为屏幕的宽
	//参数bHu为true表示胡了，需要把牌都翻转过来
	public void Paint(Graphics g, boolean bChi, boolean bSelect, boolean bHu, int scrWidth){
		int x = m_nX;
		int y = m_nY;
		int arrDisX	 = 4;
		int arrDisY	 = 13;
		int w1 	= 13;
		int w2	= 3;
		int h	= 5;
		if( !m_bPlayer )
		{//玩家的牌是从左向右画，电脑的牌则从右向左画
			w1 = -w1;
			w2 = -w2;
			h  = -h;
			arrDisX = - arrDisX;
			arrDisY = - arrDisY;
		}
		//显示杠牌
		int num = 0;
		while( num < m_nGang )
		{//四张牌为一组，中间的牌罗起来
			m_aGangBone[num].setRefPixelPosition(x, y);
			m_aGangBone[num].setState(Bone.BASE_FALL_F);
			m_aGangBone[num].Paint(g);
			num ++;
			x = x + w1;
			m_aGangBone[num].setRefPixelPosition(x, y);
			m_aGangBone[num].setState(Bone.BASE_FALL_F);
			m_aGangBone[num].Paint(g);
			num ++;
			m_aGangBone[num].setRefPixelPosition(x, y - h);
			m_aGangBone[num].setState(Bone.BASE_FALL_F);
			m_aGangBone[num].Paint(g);
			num ++;
			x = x + w1;
			m_aGangBone[num].setRefPixelPosition(x, y);
			m_aGangBone[num].setState(Bone.BASE_FALL_F);
			m_aGangBone[num].Paint(g);
			num ++;
			x = x + w1;
		}
		
		//显示暗杠
		num = 0;
		while( num < m_nAnGang )
		{//四张牌为一组，中间的牌罗起来
			m_aAnGangBone[num].setRefPixelPosition(x, y);
			m_aAnGangBone[num].setState(Bone.BASE_FALL_B);
			m_aAnGangBone[num].Paint(g);
			num ++;
			x = x + w1;
			m_aAnGangBone[num].setRefPixelPosition(x, y);
			m_aAnGangBone[num].setState(Bone.BASE_FALL_B);
			m_aAnGangBone[num].Paint(g);
			num ++;
			m_aAnGangBone[num].setRefPixelPosition(x, y - h);
			if( m_bPlayer || bHu )
				m_aAnGangBone[num].setState(Bone.BASE_FALL_F);
			else
				m_aAnGangBone[num].setState(Bone.BASE_FALL_B);
			m_aAnGangBone[num].Paint(g);
			num ++;
			x = x + w1;
			m_aAnGangBone[num].setRefPixelPosition(x, y);
			m_aAnGangBone[num].setState(Bone.BASE_FALL_B);
			m_aAnGangBone[num].Paint(g);
			num ++;
			x = x + w1;
		}
		
		//显示吃牌
		num = 0;
		while( num < m_nChi )
		{//三张牌为一组
			m_aChiBone[num].setRefPixelPosition(x, y);
			m_aChiBone[num].setState(Bone.BASE_FALL_F);
			m_aChiBone[num].Paint(g);
			num ++;
			x = x + w1;
			m_aChiBone[num].setRefPixelPosition(x, y);
			m_aChiBone[num].setState(Bone.BASE_FALL_F);
			m_aChiBone[num].Paint(g);
			num ++;
			x = x + w1;
			m_aChiBone[num].setRefPixelPosition(x, y);
			m_aChiBone[num].setState(Bone.BASE_FALL_F);
			m_aChiBone[num].Paint(g);
			num ++;
			x = x + w1;
		}
		
		//显示碰牌
		num = 0;
		while( num < m_nPeng )
		{//三张牌为一组
			m_aPengBone[num].setRefPixelPosition(x, y);
			m_aPengBone[num].setState(Bone.BASE_FALL_F);
			m_aPengBone[num].Paint(g);
			num ++;
			x = x + w1;
			m_aPengBone[num].setRefPixelPosition(x, y);
			m_aPengBone[num].setState(Bone.BASE_FALL_F);
			m_aPengBone[num].Paint(g);
			num ++;
			x = x + w1;
			m_aPengBone[num].setRefPixelPosition(x, y);
			m_aPengBone[num].setState(Bone.BASE_FALL_F);
			m_aPengBone[num].Paint(g);
			num ++;
			x = x + w1;
		}
		
		//显示手中的牌
		x = x + w2;	//手中的牌与前面的牌稍微错开点距离
		
		//当前选择的手中吃牌的索引
		int chi1 = m_aChiIndex[m_nChiIndex];
		int chi2 = m_aChiIndex[m_nChiIndex+1];
		
		for( int n = 0; n < m_nHand; n ++ ){
			m_aHandBone[n].setRefPixelPosition(x, y);
			if( bHu )				//胡了，都翻转过来
				m_aHandBone[n].setState(Bone.BASE_FALL_F);
			else if( m_bPlayer )	//玩家的牌正面朝屏幕
				m_aHandBone[n].setState(Bone.BASE_FRONT);
			else					//电脑的背正面朝屏幕
				m_aHandBone[n].setState(Bone.BASE_BACK);
			m_aHandBone[n].Paint(g);
			if( bChi )
			{//正在选择吃牌方法
				if( n == chi1 || n == chi2 )
				{	
					g.drawImage(m_ArrowImg, x-arrDisX, y-arrDisY, 0);
				}
			}
			if( bSelect && m_nSelectIndex == n )
			{//正在选择所出的牌
				g.drawImage(m_ArrowImg, x-arrDisX, y-arrDisY, 0);
			}
			x = x + w1;
		}
		
		//显示摸到的牌
		if( m_HoldBone != null ){
			if( m_bPlayer ){
				x = scrWidth - 7;
				y = m_nY - 23;
			}
			else{
				x = 7;
				y = m_nY + 18;
			}
			m_HoldBone.setRefPixelPosition(x, y);
			if( bHu )				//胡了，都翻转过来
				m_HoldBone.setState(Bone.BASE_FALL_F);
			else if( m_bPlayer )
				m_HoldBone.setState(Bone.BASE_FRONT);
			else
				m_HoldBone.setState(Bone.BASE_BACK);
			m_HoldBone.Paint(g);
			if( bSelect && m_nSelectIndex == m_nHand )
			{//正在选择所出的牌
				g.drawImage(m_ArrowImg, x-arrDisX, y-arrDisY, 0);
			}
		}
	} 
	//电脑出牌
	public Bone ComOutBone(){
		//将指定的牌与手中的牌组成新的数组
		Bone atemp[] = new Bone[m_nHand + 1];
		for( int n = 0; n < m_nHand; n++ ){
			atemp[n] = m_aHandBone[n];
		}
		atemp[m_nHand] = m_HoldBone;
		//Divide中会不断地拆分atemp中的牌，如果能拆出胡牌的结构则返回null
		Bone bone = Divide( atemp, false );
		
		for( int n = 0; n <= m_nHand; n ++ ){
			if( atemp[n] == bone ){
				if( n == m_nHand )
					m_HoldBone = null;
				else{
					m_aHandBone[n] = m_HoldBone;
					m_HoldBone = null;
				}
			}
		}
		return bone;
	}
	//按麻将规则拆分存储牌的数组
	//返回无法组合的牌，如果组成胡牌的结构则返回null
	//参数bDouble为true表示已拆除的牌中存在将牌
	public Bone Divide( Bone abone[], boolean bDouble )
	{
		/*
		if( abone.length == 3 && bDouble == false )
		{//剩下三张牌了，还没有“将”，则肯定不能胡
			return abone[0];
		}
		if( abone.length == 2 && bDouble == true )
		{//剩两张牌，但是已经有“将”了，则也肯定不能胡
			return abone[0];
		}
		if( abone.length == 1 )
		{//拆得剩1张牌了，肯定也不能胡了
			return abone[0];
		}
		if( abone.length == 0 )
		{//理论上不会有这种情况
			System.out.print("Dividie...Line16");
			return null;
		}*/
			
		int word 	= abone[0].getWord();
		int value 	= abone[0].getValue();
		
		
		int aShun[]	= new int[5];		//与第一张牌能组成顺子的牌
		int aSame[]	= new int[3];		//与第一张牌能组成“碰”的牌
		int nSameNum = 0;
		for( int n = 0; n < aShun.length; n ++ )
		{
			aShun[n] = -1;
			if( n < 3 )
				aSame[n] = -1;
		}
		
		//找出与第一张牌能组成“碰”的牌及组成顺子的牌
		for( int n = 1; n < abone.length; n ++ )
		{
			if( abone[n].getWord() == word )
			{
				if( abone[n].getValue() == value )
				{//如果牌的值相同
					aSame[nSameNum] = n;
					nSameNum ++;
				}
				else if( word != Bone.WORD_ZI )
				{//如果能组成顺子
					int index = abone[n].getValue() - value;
					if( index >= -2 && index <= 2 )
					{
						aShun[index+2] = n;
					}
				}
			}
		}
				
		Bone retBone = abone[0];
		
				
		if( nSameNum >= 2 )
		{//拆除abone中与第一张组成“碰”的牌
			if( abone.length == 3 )
			{//刚好剩三张一样的牌
				aShun = null;
				aSame = null;
				return null;
			}
			Bone atemp[] = new Bone[abone.length - 3];
			int num = 0;
			for( int n = 1; n < abone.length; n ++ )
			{
				if( n != aSame[0] && n != aSame[1] )
				{
					atemp[num] = abone[n];
					num ++;
				}
			}
			//继续拆分剩余的牌
			Bone bone = Divide(atemp, bDouble);
			if( bone == null )		//能胡牌，直接返回
			{
				atemp = null;
				aShun = null;
				aSame = null;
				return null;
			}
			retBone = bone;
				
		}
		
		if( aShun[0] != -1 && aShun[1] != -1 )
		{//拆除abone中与第一张组成第一种顺子的牌，如第一张为五万，其他两张为三万和四万
			if( abone.length == 3 )
			{//刚好剩三张顺的牌
				aShun = null;
				aSame = null;
				return null;
			}
			Bone atemp[] = new Bone[abone.length - 3];
			int num = 0;
			for( int n = 1; n < abone.length; n ++ )
			{
				if( n != aShun[0] && n != aShun[1] )
				{
					atemp[num] = abone[n];
					num ++;
				}
			}
			//继续拆分剩余的牌
			Bone bone = Divide(atemp, bDouble);
			if( bone == null )		//能胡牌，直接返回
			{
				atemp = null;
				aShun = null;
				aSame = null;
				return null;
			}
			retBone = bone;
		}

		if( aShun[1] != -1 && aShun[3] != -1 )
		{//拆除abone中与第一张组成第二种顺子的牌，如第一张为五万，其他两张为四万和六万
			if( abone.length == 3 )
			{//刚好剩三张顺的牌
				aShun = null;
				aSame = null;
				return null;
			}
			Bone atemp[] = new Bone[abone.length - 3];
			int num = 0;
			for( int n = 1; n < abone.length; n ++ )
			{
				if( n != aShun[1] && n != aShun[3] )
				{
					atemp[num] = abone[n];
					num ++;
				}
			}
			//继续拆分剩余的牌
			Bone bone = Divide(atemp, bDouble);
			if( bone == null )		//能胡牌，直接返回
			{
				atemp = null;
				aShun = null;
				aSame = null;
				return null;
			}
			retBone = bone;
		}

		if( aShun[3] != -1 && aShun[4] != -1 )
		{//拆除abone中与第一张组成第三种顺子的牌，如第一张为五万，其他两张为六万和七万
			if( abone.length == 3 )
			{//刚好剩三张顺的牌
				aShun = null;
				aSame = null;
				return null;
			}
			Bone atemp[] = new Bone[abone.length - 3];
			int num = 0;
			for( int n = 1; n < abone.length; n ++ )
			{
				if( n != aShun[3] && n != aShun[4] )
				{
					atemp[num] = abone[n];
					num ++;
				}
			}
			//继续拆分剩余的牌
			Bone bone = Divide(atemp, bDouble);
			if( bone == null )		//能胡牌，直接返回
			{
				atemp = null;
				aShun = null;
				aSame = null;
				return null;
			}
			retBone = bone;
		}
		if(  nSameNum >= 1 && bDouble == false )
		{//拆除abone中与第一张组成“将”的牌
			if( abone.length == 2 )
			{//刚好剩两张一样的牌
				aShun = null;
				aSame = null;
				return null;
			}
			Bone atemp[] = new Bone[abone.length - 2];
			int num = 0;
			for( int n = 1; n < abone.length; n ++ )
			{
				if( n != aSame[0] )
				{
					atemp[num] = abone[n];
					num ++;
				}
			}
			Bone bone = Divide(atemp, true);
			if( bone == null )		//能胡牌，直接返回
			{
				atemp = null;
				aShun = null;
				aSame = null;
				return null;
			}
			retBone = bone;
		}
		
		aShun = null;
		aSame = null;
		//返回不能组合的牌
		return retBone;
	}
}