麻将数据牌集合
private int[] cardDataArray =
{
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, //万子 1 2 3 4 5 6 7 8 9
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 17 18 19 20 21 22 23 24 25
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 33 34 35 36 37 38 39 40 41
0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //番子 49 50 51 52 53 54 55
//0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,//花
};
思路 :麻将胡牌算法为3n*2(其中2为将牌、3n为顺子或者刻子)
1、首先查找所有可以作为将牌的牌。用剩余的牌来判断是否是可以胡的。
2、剩余的牌打上断点、用数量作为值来判断是否符合顺子或者刻子的算法。
3、符合返回true 不符合返回false.
代码如下
// cbHandCard 为自己的手牌 cacheCard 为别人打得牌或者自摸得到的牌
public bool huLegal(int cacheCard, int[] cbHandCard)
{
//获取手牌数组长度
int first = cbHandCard.Length;
// 判断自己手牌的张数 mianNeed = 0 表示玩家剩余一张牌、不需要去判断将牌
int mianNeed = NeedMain(cbHandCard);
//新建集合、将所有的牌存入进去、来判断是否可以胡
int[] card = new int[first + 1];
for (int i = 0; i < first; i++)
{
card[i] = cbHandCard[i];
}
card[first] = cacheCard;
SortCardList(card); //排序
if (mianNeed == 0)
{
//表示玩家只剩余一张牌(只需判断和另外一张牌是否相等)
if (cbHandCard[0] == cacheCard) return true;
else return false;
}
else
{
//手中牌不符合胡牌规则 3n*2
if ((first + 1) % 3 != 2) return false;
else
{
//提取出所有可能为将的牌。其余长度用0补全
int[] jiangs = getJiang(card, first + 1);
//去除将牌 mians 是去除掉将牌后的牌 (因为可能有多个将牌 所以为集合)
List<int[]> mians = quJiangArrs(card, jiangs, first + 1);
//当前去除将牌后牌的长度
int size = mians.Count;
//将去除将牌后分段是否符合可胡牌型的bool值
bool[] ones = new bool[size];
//每一个断点的所有牌的集合
int[] breaks;
for (int i = 0; i < size; i++)
{
//根据打的断点 获取到第一个长度的所有牌型
breaks = getBreaks(mians[i], first - 1);
if (breaksCheck(breaks, breaks.Length))
{
//获取到的牌不符合3n的格式、直接为false
ones[i] = false;
}
else
{
//如果断点断的牌符合顺子或者刻字(3n)的格式
int[] miansparts = allParts(mians[i], breaks);
ones[i] = finalHu(miansparts, miansparts.Length);
}
}
for (int i = 0; i < size; i++)
{
if (ones[i]) return true;
}
}
}
return false;
}
接下来为上个方法所用到的一些方法
/// 是否需要将牌(玩家剩余一张牌是不需要)
int NeedMain(int[] cbHandCard)
{
int last = cbHandCard.Length;
if (last <= 1)
{
return 0;
}
return 1;
}
/// 排序手中的牌
public void SortCardList(int[] handCard)
{
List<int> sortTemp = new List<int>(handCard);
sortTemp.Sort();
for (int i = 0; i < sortTemp.Count; i++)
{
handCard[i] = sortTemp[i];
}
}
/// 查找所有的将牌
int[] getJiang(int[] cbHandCard, int cbHandCardCount)
{
int[] arr = new int[cbHandCardCount];
int count = 1;
for (int i = 1; i < cbHandCardCount; i++)
{
if (cbHandCard[i] == cbHandCard[i - 1])
{
if (count == 1) arr[i - 1] = cbHandCard[i];
count += 1;
}
else count = 1;
}
return arr;
}
/// 去除将牌、返回所有牌的情况(因为可能有多种牌做奖牌)、
// List 集合中每一个索引对应的数组都是一种排列方式
List<int[]> quJiangArrs(int[] card, int[] jiangs, int length)
{
List<int[]> list = new List<int[]>();
for (int i = 0; i < length; i++)
{
if (jiangs[i] != 0)
{
int[] src = new int[length];
int[] arr = new int[length - 2];
for (int j = 0; j < length; j++)
{
src[j] = card[j];
}
src[i] = 0x00;
src[i + 1] = 0x00;
SortCardList(src);
Array.Copy(src, 2, arr, 0, length - 2);
list.Add(arr);
}
}
return list;
}
/// 查找去除将牌后的断点(没有连续的牌就是一个断点)
/// 返回的数组为断点所在索引的集合 例如(3 4 5 7 8 9) 断点集合{0,3,6}
int[] getBreaks(int[] cbHandCard, int cbHandCardCount)
{
int[] breaks = new int[22];//首位0
int count = 1;
for (int i = 1; i < cbHandCardCount; i++)
{
if ((cbHandCard[i] - cbHandCard[i - 1]) > 1)
{
breaks[count] = i;
count += 1;
}
}
breaks[count] = cbHandCardCount;
int[] breakss = new int[count + 1];//首位0 尾位length
for (int i = 0; i < count + 1; i++)
{
breakss[i] = breaks[i];
}
return breakss;
}
/// <summary>
/// 断点后、检查所断的牌型是不是顺子或者刻子
/// 手牌 3 4 5 7 8 9 -- 断点后 0 3 6 (将牌已被丢出)
/// </summary>
/// <param name="breaks"> breaks 为断点后 下标的集合</param>
/// <param name="length"></param>
/// <returns> false 表示断牌为顺子或者刻字 true表示不符合胡牌规则 </returns>
bool breaksCheck(int[] breaks, int length)
{
for (int i = 1; i < length; i++)
{
if (breaks[i] % 3 != 0)
return true;
}
return false;
}
/// <summary>
/// 根据手牌和断点的数组 返回经过处理的牌型
/// </summary>
/// <param name="cbHandCard"> cbHandCard -- 去除将牌后的手牌</param>
/// <param name="breaks"> breaks -- 标记断点后的索引</param>
/// <returns></returns>
int[] allParts(int[] cbHandCard, int[] breaks)
{
int partnum = breaks.Length - 1; //断点个数
int[] parts = new int[partnum];
int[] arr;
for (int i = 0; i < partnum; i++)
{
arr = new int[breaks[i + 1] - breaks[i]];
for (int j = 0; j < breaks[i + 1] - breaks[i]; j++)
{
arr[j] = cbHandCard[breaks[i] + j];
}
// arr集合表示 去除将牌后的手牌根据断点分别放入的牌
parts[i] = getWei(arr, arr.Length);
}
return parts;
}
因为3n中的牌型的类型不确定。所以此处采取一种拆解法
举例 (五万、五万、五万、六万、七万、七万、八万、八万、九万)
因为此为连续的牌型、所以放入一个集合中、用牌的数量来表示 (3 1 2 2 1)
分析:取出三张牌 (3 1 2)来判断这三张牌中是否有三张相等的、如果有则去除首位 余 1 2 (后两位 2 1)
继续取出三张牌 ( 1 2 2) 三张都大于等于1 递减一 排除顺子 余 1 1 (后一位 1)
剩下三张(1 1 1) 可胡
以上思路代码实现
/// <summary>
/// 判断断点处理后的值是否符合规则
/// </summary>
/// <param name="cbCardWei"> 断点后经过处理的值 (例如 1 1 2 1 1) </param>
/// <returns></returns>
bool isMianPart(int cbCardWei)
{
int cache = cbCardWei;
for (int i = 0; i < 9; i++)
{
cache = carryChange(cache);
if (cache == 0) return true;
}
return false;
}
int carryChange(int cbCardWei)
{
int keyNum = 3;
int result = cbCardWei;
int weilength = (int)Mathf.Log10(cbCardWei) + 1;//位的长度
int weihead = (int)(cbCardWei / Mathf.Pow(10, (weilength - keyNum)));//位的头部
if (carry(weihead) != 0)
{
result = (int)(cbCardWei - (carry(weihead) * Mathf.Pow(10, (weilength - keyNum))));//位运算结果
}//前三位拆分无结果拆前两位
else
{
keyNum = 2;
weihead = (int)(cbCardWei / Mathf.Pow(10, (weilength - keyNum)));
if (carry(weihead) != 0)
{
result = (int)(cbCardWei - (carry(weihead) * Mathf.Pow(10, (weilength - keyNum))));//位运算结果
}//前两位拆分无结果只拆前一位
else
{
keyNum = 1;
weihead = (int)(cbCardWei / Mathf.Pow(10, (weilength - keyNum)));
if (carry(weihead) != 0)
{
result = (int)(cbCardWei - (carry(weihead) * Mathf.Pow(10, (weilength - keyNum))));//位运算结果
}//拆一位无结果则result结果不改变
}
}
return result;
}
int carry(int key)
{//进位
switch (key)
{
case 3: return 3;
case 4: return 3;
case 31: return 30;
case 32: return 30;
case 33: return 33;
case 44: return 33;
case 111: return 111;
case 112: return 111;
case 113: return 111;
case 114: return 114;
case 122: return 111;
case 123: return 111;
case 124: return 111;
case 133: return 111;
case 134: return 111;
case 141: return 141;
case 142: return 141;
case 143: return 141;
case 144: return 144;
case 222: return 222;
case 223: return 222;
case 224: return 222;
case 233: return 222;
case 234: return 222;
case 244: return 222;
case 311: return 300;
case 312: return 300;
case 313: return 300;
case 314: return 300;
case 322: return 300;
case 323: return 300;
case 324: return 300;
case 331: return 330;
case 332: return 330;
case 333: return 333;
case 334: return 333;
case 341: return 330;
case 342: return 330;
case 343: return 330;
case 344: return 333;
case 411: return 411;
case 412: return 411;
case 413: return 411;
case 414: return 414;
case 422: return 411;
case 423: return 411;
case 424: return 411;
case 433: return 411;
case 434: return 411;
case 441: return 441;
case 442: return 441;
case 443: return 441;
case 444: return 444;
}
return 0;
}