pokeranalyse.cpp

一个斗地主游戏的牌形分析算法,使用读取文件的方式,来测试牌的处理是否正确.

#include "PokerAnalyse.h"
//////////////////////////////////////////////
bool less_value( Poker& a, Poker& b )
{
	if( a.m_val < b.m_val )
		return true;
	else
		return false;
}

bool less_value1( PokerType& a, PokerType& b )
{
	if( a.m_value < b.m_value )
		return true;
	else
		return false;
}

bool bigger_value( Poker& a, Poker& b )
{
	if( a.m_val > b.m_val )
		return true;
	else
		return false;
}

bool unique( PokerType& a, PokerType& b )
{
	if( a.m_value==b.m_value )
		return true;
	else
		return false;
}

PokerAnalyse::PokerAnalyse()
{}

PokerAnalyse::~PokerAnalyse()
{}

bool PokerAnalyse::GetType(PokerType& pokers)
{
	for(unsigned int i=0; i<pokers.m_pokers.size(); i++)
	{
		if( pokers.m_pokers[i].m_val >= 53 )	//处理king
		{
			pokers.m_pokers[i].m_val += 48;		//最后大小王分别为101,102
			pokers.m_pokers[i].m_col = -1;
			continue;
		}
		pokers.m_pokers[i].m_col = (pokers.m_pokers[i].m_val-1) / 13;
		pokers.m_pokers[i].m_val = pokers.m_pokers[i].m_val%13;
		if( pokers.m_pokers[i].m_val==0 )	
			pokers.m_pokers[i].m_val = 13;
		if( pokers.m_pokers[i].m_val==1 )
			pokers.m_pokers[i].m_val = 14;
		if( pokers.m_pokers[i].m_val==2 )
			pokers.m_pokers[i].m_val = 16;
	}

	sort( pokers.m_pokers.begin(), pokers.m_pokers.end(), less_value );

	//判断单张
	if( pokers.m_pokers.size()==1 )
	{
		pokers.m_num = 1;
		pokers.m_type = SINGLE;
		pokers.m_value = pokers.m_pokers[0].m_val;
		return true;
	}

	//判断火箭
	if( pokers.m_pokers.size()==2 )
	{
		if( pokers.m_pokers[0].m_val>100 && pokers.m_pokers[0].m_val>100 )
		{
			pokers.m_num = 2;
			pokers.m_type = KINGS;
			pokers.m_value = 102;
			return true;
		}
	}
	
	if( AnalyseQuad( pokers ) )		//判断炸弹,四带二
		return true;
	
	if( AnalyseTrible( pokers ) )	//判断三张,三顺,飞机带翅膀
		return true;
	
	if( AnalyseDouble( pokers ) )	//判断对子,双顺
		return true;

	if( AnalyseSorted( pokers ) )	//判断顺子
		return true;

	return false;
}

bool PokerAnalyse::AnalyseSorted( PokerType& pokers_in )
{
	if( pokers_in.m_pokers.size()<5 )
		return false;

	bool flag = true;

	for( unsigned long i=0; i<pokers_in.m_pokers.size()-1; i++ )
	{
		if( pokers_in.m_pokers[i+1].m_val - pokers_in.m_pokers[i].m_val != 1 )
		{
			flag = false;
			break;
		}
	}

	if( flag )
	{
		pokers_in.m_num = pokers_in.m_pokers.size();
		pokers_in.m_type = SORTED_SINGLE;
		pokers_in.m_value = pokers_in.m_pokers[pokers_in.m_num-1].m_val;
		return true;
	}

	return false;
}

bool PokerAnalyse::AnalyseDouble( PokerType& pokers_in )
{
	if( pokers_in.m_pokers.size() % 2 != 0 )
		return false;

	vector<int> array;

	for( unsigned long i=0; i<pokers_in.m_pokers.size(); i+=2 )
	{
		if( pokers_in.m_pokers[i].m_val==pokers_in.m_pokers[i+1].m_val )
		{
			array.push_back( pokers_in.m_pokers[i].m_val );
		}
	}

	if( array.size()*2 != pokers_in.m_pokers.size() )
		return false;

	if( array.size()==1 )
	{
		pokers_in.m_num = 2;
		pokers_in.m_type = DOUBLE;
		pokers_in.m_value = array[0];
		return true;
	}

	if( array.size() >= 3 )
	{
		bool flag = true;
		for( unsigned long i=0; i<array.size()-1; i++ )
		{
			if( array[i+1]-array[i] != 1 )
			{
				flag = false;
				break;
			}
		}

		if( flag )
		{
			pokers_in.m_num = pokers_in.m_pokers.size();
			pokers_in.m_type = SORTED_DOUBLE;
			pokers_in.m_value = array[array.size()-1];
			return true;
		}
	}

	return false;
}


//传入的参数pokers必须保证有序
bool PokerAnalyse::AnalyseTrible( PokerType& pokers_in )
{
	if( pokers_in.m_pokers.size() < 3 )
		return false;

	PokerType pokers = pokers_in;

	vector<int> array;

	for( int i=0; i<(int)pokers.m_pokers.size()-2; i++ )
	{
		if( pokers.m_pokers[i].m_val==pokers.m_pokers[i+1].m_val
			&& pokers.m_pokers[i+1].m_val==pokers.m_pokers[i+2].m_val )
		{
			array.push_back(pokers.m_pokers[i].m_val);
			vector<Poker>::iterator iter = pokers.m_pokers.begin() + i;
			pokers.m_pokers.erase( iter, iter+3 );
			i--;
			
			if( i>=(int)pokers.m_pokers.size()-3 )
				break;
		}
	}

	if( array.size()==0 )
		return false;

	if( array.size()==1 && pokers.m_pokers.size()==0 )	//三张
	{
		pokers_in.m_num = 3;
		pokers_in.m_type = TRIBLE;
		pokers_in.m_value = array[0];
		return true;
	}

	if( array.size()==1 && pokers.m_pokers.size()==1 )	//三张带1
	{
		pokers_in.m_num = 4;
		pokers_in.m_type = TRIBLE_PLUS;
		pokers_in.m_value = array[0];
		pokers_in.m_trible_num = 1;
		return true;
	}

	if( array.size()==1 && pokers.m_pokers.size()==2 )	//三张带2
	{
		pokers_in.m_num = 5;
		pokers_in.m_type = TRIBLE_PLUS;
		pokers_in.m_value = array[0];
		pokers_in.m_trible_num = 1;
		return true;	
	}


	bool bsorted=true;
	if( array.size()>=2 )
	{
		for( unsigned long i=0; i<array.size()-1; i++ )
		{
			if( array[i+1]-array[i]!=1 )
			{
				bsorted = false;
				break;
			}
		}
	
		if( bsorted )
		{
			if( pokers.m_pokers.size()==0 )
			{
				pokers_in.m_num = pokers_in.m_pokers.size();
				pokers_in.m_type = SORTED_TRIBLE;
				pokers_in.m_value = array[array.size()-1];
				pokers_in.m_trible_num = array.size();
				return true;				
			}
			else if( pokers.m_pokers.size()==array.size() )
			{
				pokers_in.m_num = pokers_in.m_pokers.size();
				pokers_in.m_type = SORTED_TRIBLE_PLUS;
				pokers_in.m_value = array[array.size()-1];
				pokers_in.m_trible_num = array.size();
				return true;				
			}
			else if( pokers.m_pokers.size()==array.size()*2 )
			{
				bool b = true;
				for( unsigned long i=0; i<pokers.m_pokers.size(); i+=2 )
				{
					if( pokers.m_pokers[i+1].m_val!=pokers.m_pokers[i].m_val )
					{
						b = false;
						break;
					}
				}
				if( b )
				{
					pokers_in.m_num = pokers_in.m_pokers.size();
					pokers_in.m_type = SORTED_TRIBLE_PLUS;
					pokers_in.m_value = array[array.size()-1];
					pokers_in.m_trible_num = array.size();
					return true;		
				}
			}
		}
	}

	return false;
}


bool PokerAnalyse::AnalyseQuad( PokerType& pokers_in )
{
	PokerType pokers = pokers_in;

	if( pokers_in.m_pokers.size()==4 )	//炸弹
	{
		if( pokers_in.m_pokers[0].m_val==pokers_in.m_pokers[1].m_val
			&& pokers_in.m_pokers[1].m_val==pokers_in.m_pokers[2].m_val
			&& pokers_in.m_pokers[2].m_val==pokers_in.m_pokers[3].m_val )
		{
			pokers_in.m_num = 4;
			pokers_in.m_type = QUAD;
			pokers_in.m_value = pokers_in.m_pokers[0].m_val;
			return true;	
		}
	}
	else if( pokers_in.m_pokers.size()==6 || pokers_in.m_pokers.size()==8 )	//四张带牌
	{
		bool flag = false;
		int value = 0;
		for( unsigned long i=0; i<pokers.m_pokers.size()-3; i++ )
		{
			if( pokers.m_pokers[i].m_val==pokers.m_pokers[i+1].m_val
				&& pokers.m_pokers[i+1].m_val==pokers.m_pokers[i+2].m_val
				&& pokers.m_pokers[i+2].m_val==pokers.m_pokers[i+3].m_val )
			{
				flag = true;
				value = pokers.m_pokers[i].m_val;
				vector<Poker>::iterator iter = pokers.m_pokers.begin() + i;	//用pokers,不用pokers_in
				pokers.m_pokers.erase( iter,iter+4 );
				break;
			}
		}
		if( flag )
		{
			bool b = false;
			int cnt = 0;
			if( pokers.m_pokers.size() == 2 )
				b = true;
			else if( pokers.m_pokers.size() == 4 )
			{
				for( unsigned long i=0; i<4; i+=2 )
				{
					if( pokers.m_pokers[i].m_val==pokers.m_pokers[i+1].m_val )
						cnt++;
				}
			}

			if( cnt==2 )	b = true;
			if( b )
			{
				pokers_in.m_num = pokers_in.m_pokers.size();
				pokers_in.m_type = QUAD_PLUS;
				pokers_in.m_value = value;
				return true;
			}
		}
	}
	
	return false;
}


bool PokerAnalyse::ReadPokerFromFile( const char* filename, PokerType& pokers )//出的牌
{
	ifstream infile(filename);

	char str[256];
	long n;
	while( infile.getline( str,256,'\n' ) )
	{