pokeranalyse.cpp

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

		n = atoi(str);
		Poker poker;
		poker.m_val = n;
		pokers.m_pokers.push_back( poker );
	}

	infile.close();

	return true;
}

bool PokerAnalyse::ReadPokerFromFile( const char* filename, vector<Poker>& pokers )//手中牌
{
	ifstream infile(filename);

	char str[256];
	long n;
	while( infile.getline( str,256,'\n' ) )
	{
		n = atoi(str);
		Poker poker;
		poker.m_val  = n;
		pokers.push_back( poker );
	}

	infile.close();
	return true;
}

void PokerAnalyse::PrintType( PokerType& pokers )
{
	switch( pokers.m_type )
	{
	case SINGLE:
		cout<<"牌型:单张"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case DOUBLE:
		cout<<"牌型:对子"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case TRIBLE:
		cout<<"牌型:三张"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case TRIBLE_PLUS:
		cout<<"牌型:三张带"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case SORTED_SINGLE:
		cout<<"牌型:顺子"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case SORTED_DOUBLE:
		cout<<"牌型:双顺"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case SORTED_TRIBLE:
		cout<<"牌型:三顺"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case SORTED_TRIBLE_PLUS:
		cout<<"牌型:飞机带翅膀"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case QUAD:
		cout<<"牌型:炸弹"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case QUAD_PLUS:
		cout<<"牌型:四张带"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	case KINGS:
		cout<<"牌型:火箭"<<endl;
		PrintPokers(pokers.m_pokers);
		break;
	default:
		cout<<"错误类型"<<endl;
		break;
	}
}

void PokerAnalyse::PrintPokers(vector<Poker>& pokers)
{
	for( unsigned long i=0; i<pokers.size(); i++ )
	{
		cout<<pokers[i].m_val<<" ";
	}
	cout<<endl;
}


bool Equal( vector<Poker>& pokers, int pos, int num )
{
	if( pokers.size() < (unsigned long)num || pokers.size() < (unsigned long)pos )
		return false;
	if( num==1 )
		return true;

	for( int i=pos; i<pos+num-1; i++ )
	{
		if( pokers[i].m_val!=pokers[i+1].m_val )
			return false;
	}

	return true;
}

bool PokerAnalyse::PickOne( vector<Poker>& pokers, int value, int num, PokerType& pokers_out, bool bErase )
{
	int cnt = pokers.size()-num+1;
	for( int i=0; i<cnt; i++ )
	{
		if( pokers[i].m_val <= value )
			continue;
		if( Equal(pokers,i,num) )
		{
			pokers_out.m_value = pokers[i].m_val;
			for( int n=0; n<num; n++ )
				pokers_out.m_pokers.push_back( pokers[i] );
			if( bErase )
			{
				vector<Poker>::iterator iter = pokers.begin() + i;
				pokers.erase( iter, iter+num );
			}
			return true;
		}
	}
	return false;
}

bool PokerAnalyse::PickSorted( vector<Poker>& pokers, int value, int len, int num, PokerType& pokers_out, bool bErase )
{
	vector<Poker> _pokers = pokers;
	vector<PokerType> array;
	PokerType po;
	while( PickOne( _pokers, value-len+1, num, po ) )
	{
		array.push_back( po );
		po.m_pokers.clear();
	}
	
	if( array.size() < (unsigned long)len )
		return false;

	sort( array.begin(), array.end(), less_value1 );
	unique( array.begin(), array.end(), unique );

	int sortlen = 1;
	for( int i=0; i<(int)array.size()-1; i++ )
	{
		if( array[i+1].m_value-array[i].m_value==1 )
		{
			sortlen ++;
			if( sortlen == len )
			{
				for( int n=i-len+2; n<i+2; n++ )
				{
					for( unsigned long t=0; t<array[n].m_pokers.size(); t++ )
						pokers_out.m_pokers.push_back( array[n].m_pokers[t] );
				}
				if( bErase )
					RemovePokers( pokers, pokers_out.m_pokers );
				return true;
			}
		}
		else
			sortlen = 1;
	}

	return false;
}

bool PokerAnalyse::PickKings( vector<Poker>& pokers, PokerType& pokers_out )
{
	pokers_out.m_num = 2;
	pokers_out.m_type = KINGS;
	
	int king=0;
	int flag[2];
	for( unsigned long i=0; i<pokers.size(); i++ )
		if( pokers[i].m_val> 100 )	flag[king++] = i;
	
	if( king==2 )
	{
		pokers_out.m_value = 102;
		pokers_out.m_pokers.push_back( pokers[flag[0]] );
		pokers_out.m_pokers.push_back( pokers[flag[1]] );
		vector<Poker>::iterator iter = pokers.begin() + flag[0];
		pokers.erase( iter );
		if( flag[0]<flag[1] )
			flag[1]--;
		iter = pokers.begin() + flag[1];
		pokers.erase( iter );
		return true;
	}

	return false;
}

bool PokerAnalyse::RemovePokers( vector<Poker>& pokers, vector<Poker>& remove )
{
	if( pokers.size()<remove.size() )
		return false;

	for( unsigned long i=0; i<remove.size(); i++ )
	{
		int flag = -1;
		for( unsigned long j=0; j<pokers.size(); j++ )
		{
			int remove_val = remove[i].m_val;
			int remove_col = remove[i].m_col;
			int poker_val = pokers[j].m_val;
			int poker_col = pokers[j].m_col;
			if( remove[i].m_val==pokers[j].m_val
				&& remove[i].m_col==pokers[j].m_col )
			{
				flag = j;
				break;
			}
		}

		if(flag!=-1)
		{
			vector<Poker>::iterator iter = pokers.begin() + flag;
			pokers.erase( iter );
		}
		else
			cout<<"清牌时发生错误!"<<endl;
	}
	return true;
}

void PokerAnalyse::CopyPokers( vector<Poker>& pokers, vector<Poker>& cp )
{
	for( unsigned long i=0; i<cp.size(); i++ )
	{
		pokers.push_back( cp[i] );
	}
}

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

	sort( AllPokers.begin(), AllPokers.end(), less_value );
	bool flag;
	switch( pokers_in.m_type )
	{
	case SINGLE:
	case DOUBLE:
	case TRIBLE:
	case QUAD:
		if( PickOne( AllPokers, pokers_in.m_value, pokers_in.m_num, pokers_out ) )
			pokers_out.m_type = pokers_in.m_type;
		break;
	case SORTED_SINGLE:
		if( PickSorted( AllPokers, pokers_in.m_value, pokers_in.m_num, 1, pokers_out ) )
			pokers_out.m_type = pokers_in.m_type;
		break;
	case SORTED_DOUBLE:
		if( PickSorted( AllPokers, pokers_in.m_value, pokers_in.m_num/2, 2, pokers_out ) )
			pokers_out.m_type = pokers_in.m_type;
		break;
	case SORTED_TRIBLE:
		if( PickSorted( AllPokers, pokers_in.m_value, pokers_in.m_num/3, 3, pokers_out ) )
			pokers_out.m_type = pokers_in.m_type;
		break;
	case TRIBLE_PLUS:
		if( !PickSorted( AllPokers, pokers_in.m_value, 1, 3, pokers_out ) )
			break;
		if( !PickOne( AllPokers, -1, pokers_in.m_num-3, pokers_out ) )
		{
			CopyPokers(AllPokers,pokers_out.m_pokers);
			break;
		}
		pokers_out.m_type = TRIBLE_PLUS;
		break;
	case SORTED_TRIBLE_PLUS:
		if( !PickSorted( AllPokers, pokers_in.m_value, pokers_in.m_trible_num, 3, pokers_out) )
			break;
		flag = true;
		for( int i=0; i<pokers_in.m_trible_num; i++ )
		{
			if( !PickOne( AllPokers, -1, (pokers_in.m_num-pokers_in.m_trible_num*3)/pokers_in.m_trible_num, pokers_out) )
			{
				flag=false; 
				CopyPokers( AllPokers, pokers_out.m_pokers );
				break;
			}
		}
		if( flag )
			pokers_out.m_type = SORTED_TRIBLE_PLUS;
		break;
	case QUAD_PLUS:
		if( !PickOne( AllPokers, pokers_in.m_value, 4, pokers_out) )
			break;
		if( !PickOne( AllPokers, -1, (pokers_in.m_num-4)/2,pokers_out ) )
		{
			CopyPokers( AllPokers, pokers_out.m_pokers );
			break;
		}
		if( !PickOne( AllPokers, -1, (pokers_in.m_num-4)/2,pokers_out ) )
		{
			CopyPokers( AllPokers, pokers_out.m_pokers );
			break;
		}
		pokers_out.m_type = QUAD_PLUS;
		break;
	default:
		break;
	}

	if( pokers_out.m_type != 255 )
	{
		PrintType( pokers_out );
		return true;
	}
	else
	{
		pokers_out.m_pokers.clear();
		if( pokers_in.m_type!=QUAD || pokers_in.m_type!=KINGS )
		{	
			if( PickOne( AllPokers, -1, 4, pokers_out) )
			{
				pokers_out.m_type = QUAD;
				PrintType( pokers_out );
				return true;
			}
		}
		if( PickKings( AllPokers, pokers_out) )
		{
			pokers_out.m_type = KINGS;
			PrintType( pokers_out );
			return true;
		}
	}

	cout<<"要不起!"<<endl;

	return false;
}