斗地主游戏实现10：代码之五(牌处理)

最新推荐文章于 2024-10-17 15:58:16 发布
最新推荐文章于 2024-10-17 15:58:16 发布
阅读量339 收藏
点赞数
分类专栏： 斗地主游戏 文章标签： 游戏 J#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/book_develos/article/details/83611926
版权

1. card_op.h

#ifndef GAME_CARD_OP
#define GAME_CARD_OP
void sameVCard(int *,int *,unsigned char *,unsigned char,int);
int afterPlayHander(oppose_landocrat_playing_info *,unsigned char ,unsigned char *,unsigned char,card_type);
int getMinFitCards(card_type *, const unsigned char *,unsigned char ,unsigned char*,unsigned char);
#endif /* GAME_CARD_OP */

 

2. card_op.c

#include "game.h"

static int getFitSeq(unsigned char *,int ,unsigned char ,int ,int );
/* 出牌后处理 */
int afterPlayHander(oppose_landocrat_playing_info *playing_info,unsigned char player,unsigned char *playcards,unsigned char play_num,card_type ctype)
{
	if(playing_info->pre_player != -1) {
		xfree(playing_info->pre_cards);
	}
	int i;
	for(i = 0; i< play_num; i++) {
			playing_info->player_remain_cards[player][i] = 0;
	}
	sort_card(playing_info->player_remain_cards[player],playing_info->player_remain_count[player]);
	playing_info->next_player = (player + 1) % oppose_landocrat.player_count;
	playing_info->player_remain_count[player] -= play_num;
	playing_info->pre_player = player;
	playing_info->pre_cards = playcards;
	playing_info->pre_card_count = play_num;
	playing_info->pre_card_type = ctype;
	playing_info->players[player]->sendCardTimes++;
	if(ctype == CARD_TYPE_FOUR_BOMB || ctype == CARD_TYPE_ROCKET) {
		(playing_info->bomb_counts)++;
	}
	return 0;
}
void sameVCard(int *isc,int *start,unsigned char *nRcards,unsigned char nRnum,int snum) {
	int *tmpnum =NULL;
	tmpnum =getSameValueNum(nRcards,nRnum,1);
	isc[0] = tmpnum[4],isc[4] = tmpnum[3],isc[3] = tmpnum[2],isc[2]=tmpnum[1],isc[1]=tmpnum[0];
	xfree(tmpnum);
	start[4] = 0;
	start[0] = 0;
	start[3] = isc[4] * 4;
	start[2] = start[3] + isc[3] * 3;
	start[1] = start[2] + isc[2] * 2;
	if(snum > 1 && snum < 4) {
		unsigned char cardTmp[nRnum];
		int cv,i,j,k,rsum;
		k = 0;
		rsum = 0;
		for(cv = 4; cv >= snum; cv--) {
			if(isc[cv]) {
				for(i = 0; i < isc[cv]; i++) {
					for(j = 0; j < snum; j++) {
						cardTmp[k*snum+j] = nRcards[start[cv]+j];
					}
					for(; j < cv; j++) {
						cardTmp[nRnum - rsum -1] = nRcards[start[cv]+j];
						rsum++;
					}
					k++;
				}
				isc[cv]= 0;
			}
		}
		if(k > 0) {
			rsum = k*snum;
			isc[snum] = k;
			sort_card(cardTmp,rsum);
			for(cv = snum - 1; cv >= 1; cv--) {
				for(i = 0; i < isc[cv]; i++) {
					for(j = 0; j < cv; j++) {
						cardTmp[rsum] = nRcards[start[cv]+cv*i+j];
					}
					rsum++;
				}
			}
			sort_card(cardTmp+k*snum,nRnum - k*snum);
			memcpy(nRcards,cardTmp,nRnum);
			isc[1] = nRnum - k*snum;
			isc[2] = 0;
			isc[3] = 0;
			isc[4] = 0;
			isc[0] = 0;
			isc[snum] = k;
			start[3] = isc[4] * 4;
			start[2] = start[3] + isc[3] * 3;
			start[1] = start[2] + isc[2] * 2;
		}
		
	}

}
int getMinFitCards (card_type *ctype, const unsigned char *pcards,unsigned char card_num,unsigned char*nRcards,unsigned char nRnum) {
	int i,j;
	unsigned char tmpcard;
	unsigned char cardTmp[nRnum];
	int withSinal[3];
	int windex = 0;
	int usqc;
	int fitc;
	int isc[5];
	int start[5];
	
	sort_card(nRcards,nRnum);
	if(*ctype > CARD_TYPE_THREE_DOUBLE)
		sameVCard(isc,start,nRcards,nRnum,0);
	/*isRock = sameVCard(isc,start,nRcards,nRnum,0);*/
	switch(*ctype) {
		/* 单张牌 01 */
		case CARD_TYPE_SIGNAL:
			for(i = 0; i < nRnum; i++) {
				if((pcards[0] - 1) / 4 < (nRcards[i] - 1) / 4) {
					tmpcard = nRcards[i];
					nRcards[i] = nRcards[0];
					nRcards[0] = tmpcard;
					return 1;
				}
			}
			break;
		/* 一对牌 02 */
		case CARD_TYPE_DOUBLE:
			if(nRnum < card_num)
				break;
			for(i = 0; i < nRnum - 1; i++) {
					if((nRcards[i] -1) / 4 > (pcards[0] -1) / 4 && (nRcards[i] -1) / 4 == (nRcards[i+1] -1) / 4) {
						for(j = 0; j < 2; j++) {
							tmpcard = nRcards[i + j];
							nRcards[i + j] = nRcards[j];
							nRcards[j] = tmpcard;
						}
						return 2;
					}
			}
			break;
		
		/* 火箭（一对王） 03 */
		case CARD_TYPE_ROCKET:
			return 0;
		/* 三张牌 04 */
		case CARD_TYPE_THREE:
			if(nRnum < card_num)
				break;
			for(i = 0; i < nRnum - 2; i++) {
					if((nRcards[i] -1) / 4 > (pcards[0] -1) / 4 
						&& (nRcards[i] -1) / 4 == (nRcards[i+1] -1) / 4
						&& (nRcards[i+1] -1) / 4 == (nRcards[i+2] -1) / 4) {
						for(j = 0; j < 3; j++) {
							tmpcard = nRcards[i + j];
							nRcards[i + j] = nRcards[j];
							nRcards[j] = tmpcard;
						}
						return 3;
					}
			}
			break;
		/* 三带一 05 */
		case CARD_TYPE_THREE_SIGNAL:
			if(nRnum < card_num)
				break;
			sameVCard(isc,start,nRcards,nRnum,3);
			if(isc[3]) {
				for(i = 0; i < isc[3]; i++) {
					if(nRcards[start[3] + i * 3] > pcards[0]) {
						int fitPos = -1;
						if(isc[1]) {
							for(j = 0; j < isc[1]; j++) {
								tmpcard = nRcards[start[1] + j];
								if((tmpcard - 1) / 4 != (nRcards[start[3]] - 1) / 4) {
									fitPos = start[1] + j;
									break;
								}
							}
						}

						if(fitPos >= 0) {
							for(j = 0; j < 3; j++) {
								tmpcard = nRcards[start[3] + i * 3 + j];
								nRcards[start[3] + i * 3 + j] = nRcards[j];
								nRcards[j] = tmpcard;
							}
							tmpcard = nRcards[fitPos];
							nRcards[fitPos] = nRcards[3];
							nRcards[3] = tmpcard;
							return 4;
						}

						
					}
				}
			}
			break;
		/* 三带一对 06 */
		case CARD_TYPE_THREE_DOUBLE:
			if(nRnum < card_num)
				break;
			sameVCard(isc,start,nRcards,nRnum,3);
			if(isc[3]) {
				for(i = 0; i < isc[3]; i++) {
					if(nRcards[start[3] + i * 3] > pcards[0]) {
						int fitPos = -1;
						for(j = 0; j < 3; j++) {
								tmpcard = nRcards[start[3] + i * 3 + j];
								nRcards[start[3] + i * 3 + j] = nRcards[j];
								nRcards[j] = tmpcard;
						}
						sameVCard(isc,start,nRcards+3,nRnum-3,2);
						if(isc[2]) {
							fitPos = start[3] + isc[3] * 3 + 3;
						}
						
						if(fitPos >= 0) {
							for(j = 0; j < 2; j++) {
								tmpcard = nRcards[fitPos+j];
								nRcards[fitPos+j] = nRcards[3 + j];
								nRcards[3 + j] = tmpcard;
							}
							return 5;
						}
					}
				}
			}
			break;
		/* 炸*弹 07 */
		case CARD_TYPE_FOUR_BOMB:
			return 0;
			/*
			if(nRnum < card_num)
				break;
			for(i = 0; i < isc[4]; i++) {
					if(nRcards[i * 4] > pcards[0]) {
						for(j = 0; j < 4; j++) {
								tmpcard = nRcards[i * 4 + j];
								nRcards[i * 4 + j] = nRcards[j];
								nRcards[j] = tmpcard;
						}
						return 4;
					}
			}*/
			break;
		/* 单顺 08 */
		case CARD_TYPE_SEQUENCE_SIGNAL:
			if(nRnum < card_num)
				break;
			usqc = nRnum-start[3];
			if(isc[1])
			for(i = start[1]; i < nRnum; i++) {
				cardTmp[i-start[1]] = nRcards[i];
			}
			if(isc[2]) {
				for(i = 0; i < isc[2]; i++) {
					cardTmp[isc[1] + i] = nRcards[start[2] + i * 2];
					usqc--;
					cardTmp[usqc] = nRcards[start[2] + i * 2 + 1];
				}
			}
			if(isc[3]) {
				for(i = 0; i < isc[3]; i++) {
					cardTmp[isc[1] + isc[2] + i] = nRcards[start[3] + i * 3];
					usqc--;
					cardTmp[usqc] = nRcards[start[3] + i * 3 + 2];
					usqc--;
					cardTmp[usqc] = nRcards[start[3] + i * 3 + 1];
				}
			}
			fitc= getFitSeq(cardTmp,usqc,pcards[0],card_num,1);
			if(fitc >= 0) {
				for(i = 0; i < card_num; i++) {
					tmpcard = cardTmp[fitc + i];
					cardTmp[fitc + i] = cardTmp[i];
					cardTmp[i] = tmpcard;
				}
				if(isc[4]) {
					for(i = 0; i < isc[4]; i++) {
						for(j = 0; j < 4; j++) {
							nRcards[nRnum - 1 - i*4 -j] =  nRcards[i * 4 + j];
						}
					}
				}
				for(i = 0; i < nRnum-start[3]; i++) {
					nRcards[i] = cardTmp[i];
				}
				return card_num;
			}
			break;
		/* 双顺 09 */
		case CARD_TYPE_SEQUENCE_DOUBLE:
			if(nRnum < card_num)
				break;
			usqc = nRnum-start[3]-isc[1];
			if(isc[1])
			for(i = start[1]; i < nRnum; i++) {
				cardTmp[usqc+i-start[1]] = nRcards[i];
			}
			if(isc[2]) {
				for(i = 0; i < isc[2]; i++) {
					cardTmp[i*2] = nRcards[start[2] + i * 2];
					cardTmp[i*2+1] = nRcards[start[2] + i * 2 + 1];
				}
			}
			if(isc[3]) {
				for(i = 0; i < isc[3]; i++) {
					cardTmp[isc[2]*2 + i * 2] = nRcards[start[3] + i * 3];
					cardTmp[isc[2]*2 + i * 2 + 1] = nRcards[start[3] + i * 3 + 1];
					usqc--;
					cardTmp[usqc] = nRcards[start[3] + i * 3 + 2];
				}
			}
			fitc= getFitSeq(cardTmp,usqc,pcards[0],card_num,2);
			if(fitc >= 0) {
				for(i = 0; i < card_num; i++) {
					tmpcard = cardTmp[fitc + i];
					cardTmp[fitc + i] = cardTmp[i];
					cardTmp[i] = tmpcard;
				}
				if(isc[4]) {
					for(i = 0; i < isc[4]; i++) {
						for(j = 0; j < 4; j++) {
							nRcards[nRnum - 1 - i*4 -j] =  nRcards[i * 4 + j];
						}
					}
				}
				for(i = 0; i < nRnum-start[3]; i++) {
					nRcards[i] = cardTmp[i];
				}
				return card_num;
			}
			break;
		/* 三顺 10 */
		case CARD_TYPE_SEQUENCE_THREE:
			if(nRnum < card_num)
				break;
			if(isc[4]) {
				for(i = 0; i < isc[4]; i++) {
					for(j = 0; j < 3; j++) {
						cardTmp[i*3+j] = nRcards[i*4+j];
					}
					cardTmp[nRnum - i -1] = nRcards[i*4+j];
				}
			}
			for(i = isc[4]*3; i < nRnum - isc[4]; i++) {
				cardTmp[i] = nRcards[i+isc[4]];
			}
			fitc= getFitSeq(cardTmp,nRnum-isc[4]-isc[2]*2-isc[1],pcards[0],card_num,3);
			if(fitc >= 0) {
				for(i = 0; i < card_num; i++) {
					tmpcard = cardTmp[fitc + i];
					cardTmp[fitc + i] = cardTmp[i];
					cardTmp[i] = tmpcard;
				}
				for(i = 0; i < nRnum; i++) {
					nRcards[i] = cardTmp[i];
				}
				return card_num;
			}
			break;
		/* 飞机带翅膀：三顺＋同数量的单牌 11 */
		case CARD_TYPE_SEQUENCE_THREE_WINGS_SIGNAL: 
			if(nRnum < card_num)
				break;
			if(isc[4]) {
				for(i = 0; i < isc[4]; i++) {
					for(j = 0; j < 3; j++) {
						cardTmp[i*3+j] = nRcards[i*4+j];
					}
					cardTmp[nRnum - i -1] = nRcards[i*4+j];
				}
			}
			for(i = isc[4]*3; i < nRnum - isc[4]; i++) {
				cardTmp[i] = nRcards[i+isc[4]];
			}
			fitc= getFitSeq(cardTmp,nRnum-isc[4]-isc[2]*2-isc[1],pcards[0],card_num-card_num/4,3);
			if(fitc >= 0) {
				int notNextWings[card_num/4];
				int nextNotWinIndex = card_num/4;
				for(i = 0; i < card_num; i++) {
					tmpcard = cardTmp[fitc + i];
					cardTmp[fitc + i] = cardTmp[i];
					cardTmp[i] = tmpcard;
					if(i % 3 == 0) {
						notNextWings[i/3] = i;
					}
				}
				int hasEmperor = 0;
				for(i = card_num-card_num/4; i < nRnum; i++) {
					int isn = 1;
					for(j = 0; j < nextNotWinIndex; j++) {
						if(hasEmperor && (cardTmp[i] == 57 || cardTmp[i] == 61)) {
							isn = 0;
							break;
						}
						if(!hasEmperor && (cardTmp[i] == 57 || cardTmp[i] == 61))
							hasEmperor = 1;
						if((cardTmp[i] - 1) / 4 == (cardTmp[notNextWings[j]] - 1) / 4) {
							isn = 0;
							break;
						}
					}
					if(isn) {
						cardTmp[nextNotWinIndex++] = i;
					}
					if(nextNotWinIndex == card_num/2)
						break;
				}
				printf("nextNotWinIndex=%d\n",nextNotWinIndex);
					if (nextNotWinIndex == card_num/2) {
						for(i = card_num/4;i < nextNotWinIndex; i++) {
							tmpcard = cardTmp[notNextWings[i]];
							cardTmp[notNextWings[i]] = cardTmp[card_num/4*3+i-card_num/4];
							cardTmp[card_num/4*3+i-card_num/4] = tmpcard;
						}
						return card_num;
					}
			}
			break;
		/* 飞机带翅膀：三顺＋同数量的对牌 12 */
		case CARD_TYPE_SEQUENCE_THREE_WINGS_DOUBLE: 
			if(nRnum < card_num)
				break;
			if(isc[4]) {
				for(i = 0; i < isc[4]; i++) {
					for(j = 0; j < 3; j++) {
						cardTmp[i*3+j] = nRcards[i*4+j];
					}
					cardTmp[nRnum - i -1] = nRcards[i*4+j];
				}
			}
			for(i = isc[4]*3; i < nRnum - isc[4]; i++) {
				cardTmp[i] = nRcards[i+isc[4]];
			}
			fitc= getFitSeq(cardTmp,nRnum-isc[4]-isc[2]*2-isc[1],pcards[0],card_num-card_num/5*2,3);
			if(fitc >= 0) {
				int notNextWings[card_num/5*2];
				int nextNotWinIndex = card_num/5;
				for(i = 0; i < card_num; i++) {
					tmpcard = cardTmp[fitc + i];
					cardTmp[fitc + i] = cardTmp[i];
					cardTmp[i] = tmpcard;
					if(i % 3 == 0) {
						notNextWings[i/3] = i;
					}
				}
				int hasEmperor = 0;
				for(i = card_num-card_num/4; i < nRnum; i++) {
					int isn = 1;
					for(j = 0; j < nextNotWinIndex; j++) {
						if(hasEmperor && (cardTmp[i] == 57 || cardTmp[i] == 61)) {
							isn = 0;
							break;
						}
						if(!hasEmperor && (cardTmp[i] == 57 || cardTmp[i] == 61))
							hasEmperor = 1;
						if((cardTmp[i] - 1) / 4 == (cardTmp[notNextWings[j]] - 1) / 4) {
							isn = 0;
							break;
						}
						if(i== nRnum -1 || (cardTmp[i] - 1) / 4 != (cardTmp[i+1] - 1) / 4) {
							i++;
							isn = 0;
							break;
						}
					}
					if(isn) {
						cardTmp[nextNotWinIndex++] = i;
					}
				}
				
					if (nextNotWinIndex == card_num/5*2) {
						for(i = card_num/5;i < nextNotWinIndex; i++) {
							tmpcard = cardTmp[notNextWings[i]];
							cardTmp[notNextWings[i]] = cardTmp[card_num/5*3+i-card_num/5];
							cardTmp[card_num/4*3+i-card_num/4] = tmpcard;
							tmpcard = cardTmp[notNextWings[i]+1];
							cardTmp[notNextWings[i]+1] = cardTmp[card_num/5*3+i-card_num/5+1];
							cardTmp[card_num/5*3+i-card_num/5+1] = tmpcard;
						}
						return card_num;
					}
			}
			break;
		/* 四带两个单牌 13 */
		case CARD_TYPE_FOUR_DOUBLE_SIGNAL: 
			if(nRnum < card_num)
				break;
			if(!isc[4])
				break;
			if(isc[4]+isc[3]+isc[2]+isc[1] < 3)
				break;
			windex = 0;
			for(i = 0; i < isc[4]; i++) {
					if(nRcards[i * 4] > pcards[0]) {
						windex = 0;
						withSinal[windex++] = i*4;
						if(isc[1]) {
							if(!(isc[1] == 2 && nRcards[start[1]] == 57 && nRcards[start[1]] == 61)) {
								withSinal[windex++] = start[1];
								if (isc[1] > 1)
								{
									withSinal[windex++] = start[1]+1;
								}
							}
						}
						if(windex < 3 && isc[2]) {
							withSinal[windex++] = start[2];
							if(windex < 3 && isc[2] > 1)
								withSinal[windex++] = start[2]+2;
						}
						if(windex < 3 && isc[3]) {
							withSinal[windex++] = start[3];
							if(windex < 3 && isc[3] > 1)
								withSinal[windex++] = start[3]+3;
						}
						if(windex < 3 && isc[4]) {
							int start4 = 0;
							if((nRcards[start4] -1)/4 != (nRcards[i*4]-1)/4)
								withSinal[windex++] = start4;
							start4 += 4;
							if(windex < 3 && isc[4] > 1 && (nRcards[start4] -1)/4 != (nRcards[i*4]-1)/4)
								withSinal[windex++] = start4;
							start4 += 4;
							if(windex < 3 && isc[4] > 2 && (nRcards[start4] -1)/4 != (nRcards[i*4]-1)/4)
								withSinal[windex++] = start4;
								
						}
						if(windex == 3) {
							for(j = 0; j < 4; j++) {
								tmpcard = nRcards[withSinal[0]];
								nRcards[withSinal[0]] = nRcards[j];
								nRcards[j] = tmpcard;
							}
							for(j = 1; j < 3; j++) {
								tmpcard = nRcards[withSinal[j]];
								nRcards[withSinal[j]] = nRcards[3+j];
								nRcards[3+j] = tmpcard;
							}
							return card_num;
						}
							
					}
			}

			break;
			/* 四带两对 14 */
			case CARD_TYPE_FOUR_DOUBLE_DOUBLE: 
				if(nRnum < card_num)
					break;
				if(!isc[4])
					break;
				if(isc[4]+isc[3]+isc[2]+isc[1] < 3)
					break;
				int withSinal[3];
				int windex = 0;
				for(i = 0; i < isc[4]; i++) {
						if(nRcards[i * 4] > pcards[0]) {
							windex = 0;
							withSinal[windex++] = i*4;
							if(isc[2]) {
								withSinal[windex++] = start[2];
								if(windex < 3 && isc[2] > 1)
									withSinal[windex++] = start[2]+2;
							}
							if(windex < 3 && isc[3]) {
								withSinal[windex++] = start[3];
								if(windex < 3 && isc[3] > 1)
									withSinal[windex++] = start[3]+3;
							}
							if(windex < 3 && isc[4]) {
								int start4 = 0;
								if((nRcards[start4] -1)/4 != (nRcards[i*4]-1)/4)
									withSinal[windex++] = start4;
								start4 += 4;
								if(windex < 3 && isc[4] > 1 && (nRcards[start4] -1)/4 != (nRcards[i*4]-1)/4)
									withSinal[windex++] = start4;
								start4 += 4;
								if(windex < 3 && isc[4] > 2 && (nRcards[start4] -1)/4 != (nRcards[i*4]-1)/4)
									withSinal[windex++] = start4;
									
							}
							if(windex == 3) {
								for(j = 0; j < 4; j++) {
									tmpcard = nRcards[withSinal[0]];
									nRcards[withSinal[0]] = nRcards[j];
									nRcards[j] = tmpcard;
								}
								for(j = 0; j < 1; j++) {
									tmpcard = nRcards[withSinal[j+1]];
									nRcards[withSinal[j+1]] = nRcards[4+j*2];
									nRcards[4+j*2] = tmpcard;
									tmpcard = nRcards[withSinal[j+1]+1];
									nRcards[withSinal[j+1]+1] = nRcards[4+j*2+1];
									nRcards[4+j*2+1] = tmpcard;
								}
								return card_num;
							}
								
						}
				}
				break;

				case CARD_TYPE_ERROR:
					return 0;
				default :
					break;
	}
	

	
	/*
	if(*ctype == CARD_TYPE_FOUR_BOMB) {
		fitR = 0;
		for(i = 0;i < isc[4]; i++) {
			if(nRcards[i*4] > pcards[0]) {
				fitR = i + 1;
				break;
			}
		}
	}
	*/
	/*
	int fitR = 1;
	if(fitR) {
		*ctype = CARD_TYPE_FOUR_BOMB;
		for(i = 0; i < 4; i++) {
			tmpcard = nRcards[(fitR-1)*4+i];
			nRcards[(fitR-1)*4+i] = nRcards[i];
			nRcards[i] = tmpcard;
		}
		return 4;
	}
	if(isRock) {
		*ctype = CARD_TYPE_ROCKET;
		for(i = 0; i < 2; i++) {
			tmpcard = nRcards[nRnum-2+i];
			nRcards[nRnum-2+i] = nRcards[i];
			nRcards[i] = tmpcard;
		}
		return 2;
	}
	*/
	return 0;
}

static int getFitSeq(unsigned char *cards,int card_num,unsigned char preStart,int preCount,int fitValue) {
	int i;
	int rvalue = -1;
	printf("card_num=%d,cards: ",card_num);
	for (i = 0;i < card_num;i++) {
		printf("%d,",(cards[i]-1) / 4 + 3);
	}
	printf("\n");
	if(card_num < preCount)
		return -1;
	sort_card(cards,card_num);
	for(i = 0; i < card_num / fitValue; i++) {
		printf("i=%d,cardvalue=%d\n",i,(cards[i*fitValue] - 1) / 4 + 3);
		if((cards[i*fitValue] - 1) / 4 > (preStart - 1) / 4) {
			break;
		}
	}

	if(i > 0 && ((cards[i*fitValue-fitValue] - 1) / 4 > (preStart - 1) / 4)) {
		printf("(cards[i*fitValue-fitValue] - 1) / 4=%d\n",(cards[i*fitValue-fitValue] - 1) / 4);
		i--;
	}
	if(card_num - i * fitValue < preCount)
		return -1;
	for(; i <= (card_num - preCount) / fitValue; i++) {
		printf("i=%d,fitValue=%d\n",i,fitValue);
		if(cardsIsNumSequence(cards + i * fitValue,preCount,fitValue)) {
			rvalue = i * fitValue;
			break;
		}
	}
	printf("rvalue=%d,fitValue=%d\n",rvalue,fitValue);
	return rvalue;
}

 

book_develos
关注
专栏目录
JS 单机版 斗地主 AI 2.0版本
12-21
完善JS斗地主AI1.0测试版中的BUG,更换部分界面，优化部分代码， 添加 相应的结算界面。不须刷新即可进入下局游戏。
cocos2d-x 斗地主源码
12-27
cocos2d-x 编写的斗地主源码，使用C++语言，代码中实现了斗地主中的洗牌、发牌等操作。
nodejs-server-wechat-landLordGame:微信小游戏-斗地主，包含nodejs-服务器
05-08
nodejs-server-wechat-landLordGame 学习nodejs搭建一个服务器群的过程，还不完善仅做测试，不过目前微信游戏斗地主是可以玩的，慢慢做提升 landLordGame 是微信小游戏客户端代码 littleServer 是nodejs服务器代码 下面是我的一些效果图：
斗地主之推测
jxandrew的专栏
11-01 613
经过前面所说的调整和改进，终于进入了打牌水平可随规则数增加的正轨。但不久又出问题了:(这个问题的现象很简单，解决起来却很复杂：跳打。比如地主出了张2，下家在不清楚小鬼分布的情况下就直接出了大鬼，结果就导致地主的小鬼升级了。粗看起来应该也比较好解决，增加点规则来判断下小鬼的分布情况就是了。比如：如果地主出了二，最后是门板用大鬼拦截，则说明小鬼都在地主手中。我们之前也曾讨论过判断问题，比如地主各牌型的强
Qt斗地主游戏开发＜三＞：主界面初始化显示
欧特GO
10-14 912
Qt斗地主游戏开发＜三＞：主界面初始化显示
斗地主发牌的实现的思路php,JavaScript实现斗地主游戏的思路
weixin_35039018的博客
03-11 338
本文知识给大家分享一下使用js写斗地主的思路，代码写的不好，还请见谅。这里说说斗地主主要包含的功能：洗牌，发牌，玩家出牌、电脑出牌，出牌规则的验证，输赢啥的没有判断，只是实现了这几个主要功能，下面依次说说几个功能的实现：1.洗牌：var pukes=this.manage.pukes;//存放扑克牌的数组//洗牌for(var i=;ivar tmp=pukes[i];var index=util...
纯前端实现JavaScript斗地主代码.zip
08-10
《纯前端实现JavaScript斗地主代码》是一款基于JavaScript编写的在线斗地主游戏，可以直接在谷歌浏览器上运行，为用户提供三人对战的游戏体验。玩家可以选择叫分，包括1分、2分或3分，游戏机制遵循传统的斗地主规则...
python模拟实现斗地主发牌
09-18
在这个问题中，我们创建一个`doudizhu`类来代表斗地主游戏，并在其中实现初始化、洗牌、发牌、抢地主、理牌以及牌面和花色的对应功能。 首先，类的`__init__`方法用于初始化54张扑克牌，将它们编号0到53，并存储在...
基于C++实现斗地主小游戏
08-28
在本项目中，"基于C++实现斗地主小游戏"是一个用C++编程语言开发的简单人工智能单机斗地主游戏。斗地主是一种在中国非常流行的扑克牌游戏，通常需要三名玩家参与，但在这个单机版本中，游戏可能设计为用户与两个...
史上最全斗地主发牌代码实现.rar
11-24
如果你完成了出牌规则和积分计算的代码，那么你的斗地主游戏就已经相当完整了，可以与朋友们在线上进行对战。如果你有任何进展或遇到问题，与其他开发者交流是很好的学习方式，正如描述中提到的，可以私信分享你的...
C# Winform斗地主游戏源码
09-04
6. **数据结构与算法**：斗地主游戏涉及大量的牌型判断和出牌策略，这需要用到数据结构（如数组、列表）和算法（如排序、查找）。例如，源码可能包含用以排序扑克牌、检查是否能接牌的算法。 7. **游戏逻辑实现**：...
斗地主代码实现分析
练功！
07-05 7494
1.流程图详细记录游戏进行的流程，具体到每个动作，选择，以及最后会出现的所有结果。 2.类图分析游戏中设计的类和方法，以及类之间的关系 3.时序图类之间消息的传递过程，未完成 4.代码实现游戏功能的实现…..5.这四者关系分析为什么需要那三张图？ 整个项目是完成了，但是只有代码，和别人沟通每个细节会比较困难，这时就需要其他的说明文件来帮助别人理解。 思考以上三张图和代码实现的关系： 流程
作业04 一个简单的扑克牌游戏
weixin_30568715的博客
04-07 284
程序设计要求 设计一个Card类来表示单张扑克牌的逻辑模型。如下类图所示。 设计一个Deck类用来表示一副52张的扑克牌，公有接口必须包括生成扑克牌、显示扑克牌、洗牌等这样的成员函数。如下类图所示。 程序主函数如下： int main() { Deck deck; deck.MakeDeck(); deck.ShowDeck(); re...
斗地主中的提示出牌算法(Lua)
hyx18775752051的博客
03-27 4139
没有看到别人怎么写的，这个是上家公司老板写的，当时服务器用的js写的，我搬到了客户端上，换成了lua。然后现在工作要用到，一时还想不起来。所以说造过的轮子要记录下来，方便自己，也方便他人。 主要的思路就是根据上家的出牌，先判断出type(单，对，顺子，炸弹等)，然后根据type去寻找该类型的所有牌组合。所以每个类型都要有个对应的方法。可以在找的时候直接传入参数，直接找大于该牌的组合。也可以找出该...
项目：用VS类图设计“扑克牌”类库
weixin_30318645的博客
05-06 130
转载于:https://www.cnblogs.com/lizunicon/archive/2008/05/06/1184998.html
【游戏模组】极品飞车12无间风云冬季mod，冬天版本的无间风云你体验过吗
u012373255的博客
10-16 345
极品飞车12：无间风云》回归到极品飞车的本源，并再次引了危险刺激的警察追击赛以及全世界最热辣吸引的公路追击赛。和《极品飞车9》一样，仍然只支持白天。极品飞车12的游戏mod一直比较少，更多的游戏模组玩家更愿意为极品飞车78910四代制作mod，而我今天就为大家带来了极品飞车12的mod，你将体验到在冬季大学纷飞的气候条件下游玩极品飞车12。《极品飞车12：无间风云》是由Black Box游戏制作室开发的竞速类游戏，于2008年11月18日在北美首发、2008年11月21日在欧洲先后推出。
《七度荒域:混沌之树》风灵月影二十二项游戏辅助：上帝模式/无限HP和EP/金币不减
最新发布
h535067760的博客
10-17 574
七度荒域:混沌之树》是款国产Roguelike银河恶魔城横版动作游戏，融合刷宝玩法。玩家将扮演修补世界的命运之子，探寻碎裂世界的秘密，在战斗轮回中成长，挑战未知与隐秘力量。风灵月影版修改器提供更多自定义和游戏体验调整选项，增强玩家乐趣。1退出杀毒软件并关闭 Windows Defender。2 启动游戏(非正版游戏修改可能无法生效)4.等待提示“启动成功”后，可开始修改。3.游戏运行后点击“一键启动”按钮。
Unity3D 观察者模式
2301_76984003的博客
10-13 666
Unity3D 泛型事件系统
Java斗地主游戏项目：可直接运行的代码
2. 斗地主游戏规则实现：斗地主是一种流行的扑克牌游戏，本项目将实现斗地主的基本规则，包括牌的发放、牌型的判断、出牌的策略以及胜利条件的判断等。 3. 图形用户界面（GUI）设计：项目中应包含图形用户界面，用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值