private static List <MsgCardHand> SearchUseableSingle(List <int> hands2)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands2);
// 找一个较大的单张
for (var newBombSuitID = 1; newBombSuitID < (int)pokerface.CardID.JOB / 4; newBombSuitID++)
{
if (slots[newBombSuitID] > 0)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Single;
cardHand.cards.AddRange(extractCardByRank(hands2, newBombSuitID, 1));
cardHands.Add(cardHand);
}
}
// 自己有2，那就是最大
if (slots[0] > 0)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Single;
cardHand.cards.AddRange(extractCardByRank(hands2, 0, 1));
cardHands.Add(cardHand);
}
return(cardHands);
}
private static List <MsgCardHand> SearchLongestFlush(List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
// 简单起见从3开始搜索，不考虑ACE开始的类似12345这种
for (var newBombSuitID = 1; newBombSuitID <= (int)pokerface.CardID.AH / 4;)
{
var testBombRankID = newBombSuitID;
for (var i = 0; i < 13; i++)
{
if (slots[testBombRankID + i] < 1)
{
// 找到了
if (i > 4)
{
var cardHand = new MsgCardHand();
cardHand.cards.AddRange(extractCardByRanks(hands, testBombRankID, testBombRankID + i - 1, 1));
cardHands.Add(cardHand);
}
break;
}
}
newBombSuitID = newBombSuitID + 1;
}
return(cardHands);
}
/// <summary>
/// 寻找所有大于上一手"炸弹"的有效组合
/// </summary>
/// <param name="prev">上一手牌</param>
/// <param name="hands">手上的所有牌</param>
/// <returns>返回一个牌组列表，如果没有有效牌组，该列表长度为0</returns>
private static List <MsgCardHand> FindBombGreatThan(MsgCardHand prev, List <int> hands)
{
// 注意不需要考虑333这种炸弹，因为他是最小的，而现在是寻找一个大于某个炸弹的炸弹
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
var bombCardRankID = (prev.cards[0]) / 4;
for (var newBombSuitID = bombCardRankID + 1; newBombSuitID < (int)pokerface.CardID.AH / 4; newBombSuitID++)
{
if (slots[newBombSuitID] > 3)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Bomb;
cardHand.cards.AddRange(extractCardByRank(hands, newBombSuitID, 4));
cardHands.Add(cardHand);
}
}
// 如果有3个ACE，也是炸弹
if (slots[(int)pokerface.CardID.AH / 4] > 2)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Bomb;
cardHand.cards.AddRange(extractCardByRank(hands, (int)pokerface.CardID.AH / 4, 3));
cardHands.Add(cardHand);
}
return(cardHands);
}
private static List <MsgCardHand> SearchLongestPairX(List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
for (var newBombSuitID = 0; newBombSuitID <= (int)pokerface.CardID.AH / 4;)
{
var testBombRankID = newBombSuitID;
for (var i = 0; i < 13; i++)
{
if (slots[testBombRankID + i] < 2)
{
// 找到了
if (i >= 1)
{
var cardHand = new MsgCardHand();
cardHand.cards.AddRange(extractCardByRanks(hands, testBombRankID, testBombRankID + i - 1, 2));
cardHands.Add(cardHand);
}
break;
}
}
newBombSuitID = newBombSuitID + 1;
}
return(cardHands);
}
/// <summary>
/// 判断当前的手牌是否大于上一手牌
/// </summary>
/// <param name="prevCardHand">上一手牌</param>
/// <param name="current">当前的手牌</param>
/// <returns>如果大于则返回true，其他各种情形都会返回false</returns>
public static bool agariGreatThan(MsgCardHand prevCardHand, MsgCardHand current)
{
// 如果当前的是炸弹
//if (current.cardHandType == (int)CardHandType.Bomb)
//{
// // 上一手不是炸弹
// if (prevCardHand.cardHandType != (int)CardHandType.Bomb)
// {
// return true;
// }
// // 上一手也是炸弹，则比较炸弹牌的大小，大丰关张不存在多于4个牌的炸弹
// return current.cards[0]/4 > prevCardHand.cards[0]/4;
//}
//// 如果上一手牌是炸弹
//if (prevCardHand.cardHandType == (int)CardHandType.Bomb)
//{
// return false;
//}
//// 必须类型匹配
//if (prevCardHand.cardHandType != current.cardHandType)
//{
// return false;
//}
//// 张数匹配
//if (prevCardHand.cards.Count != current.cards.Count)
//{
// return false;
//}
//// 单张时，2是最大的
//if (prevCardHand.cardHandType == (int)CardHandType.Single)
//{
// if (prevCardHand.cards[0] / 4 == 0)
// {
// return false;
// }
// if (current.cards[0] / 4 == 0)
// {
// return true;
// }
//}
//// 现在只比较最大牌的大小
//return current.cards[0]/4 > prevCardHand.cards[0]/4;
return(false);
}
/// <summary>
/// 寻找手牌上的所有炸弹
/// </summary>
/// <param name="hands">手上的所有牌</param>
/// <returns>返回一个牌组列表，如果没有有效牌组，该列表长度为0</returns>
private static List <MsgCardHand> FindBomb(List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
for (var newBombSuitID = 0; newBombSuitID < (int)pokerface.CardID.AH / 4; newBombSuitID++)
{
if (slots[newBombSuitID] > 3)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Bomb;
cardHand.cards.AddRange(extractCardByRank(hands, newBombSuitID, 4));
cardHands.Add(cardHand);
}
}
// 如果有3个ACE，也是炸弹
if (slots[(int)pokerface.CardID.AH / 4] > 2)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Bomb;
cardHand.cards.AddRange(extractCardByRank(hands, (int)pokerface.CardID.AH / 4, 3));
cardHands.Add(cardHand);
}
// 黑桃梅花方块3组成炸弹
List <int> three = new List <int>();
foreach (var h in hands)
{
if (h / 4 == (int)pokerface.CardID.R3H / 4 && h != (int)pokerface.CardID.R3H)
{
three.Add(h);
}
}
if (three.Count == 3)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Bomb;
cardHand.cards.AddRange(three);
cardHands.Add(cardHand);
}
return(cardHands);
}
/// <summary>
/// 寻找所有大于上一手"顺子"的有效组合
/// </summary>
/// <param name="prev">上一手牌</param>
/// <param name="hands">手上的所有牌</param>
/// <returns>返回一个牌组列表，如果没有有效牌组，该列表长度为0</returns>
private static List <MsgCardHand> FindFlushGreatThan(MsgCardHand prev, List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
var flushLen = prev.cards.Count;
var bombCardRankID = prev.cards[0] / 4; // 最大的顺子牌rank
var seqLength = flushLen / 1;
for (var newBombSuitID = bombCardRankID + 1; newBombSuitID <= (int)pokerface.CardID.AH / 4;)
{
var testBombRankID = newBombSuitID;
var found = true;
for (var i = 0; i < seqLength; i++)
{
if (slots[testBombRankID - i] < 1)
{
newBombSuitID = newBombSuitID + 1;
found = false;
break;
}
}
// 找到了
if (found)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Flush;
cardHand.cards.AddRange(extractCardByRanks(hands, testBombRankID - seqLength + 1, testBombRankID, 1));
cardHands.Add(cardHand);
newBombSuitID = newBombSuitID + 1;
}
}
return(cardHands);
}
/// <summary>
/// 寻找所有大于上一手"对子"的有效组合
/// </summary>
/// <param name="prev">上一手牌</param>
/// <param name="hands">手上的所有牌</param>
/// <returns>返回一个牌组列表，如果没有有效牌组，该列表长度为0</returns>
private static List <MsgCardHand> FindPairGreatThan(MsgCardHand prev, List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
var bombCardRankID = prev.cards[0] / 4;
// 找一个较大的对子
for (var newBombSuitID = bombCardRankID + 1; newBombSuitID < (int)pokerface.CardID.JOB / 4; newBombSuitID++)
{
if (slots[newBombSuitID] > 1)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Pair;
cardHand.cards.AddRange(extractCardByRank(hands, newBombSuitID, 2));
cardHands.Add(cardHand);
}
}
return(cardHands);
}
/// <summary>
/// 寻找所有大于上一手"单张"的有效组合
/// </summary>
/// <param name="prev">上一手牌</param>
/// <param name="hands">手上的所有牌</param>
/// <returns>返回一个牌组列表，如果没有有效牌组，该列表长度为0</returns>
private static List <MsgCardHand> FindSingleGreatThan(MsgCardHand prev, List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
var bombCardRankID = prev.cards[0] / 4;
if (bombCardRankID == 0)
{
// 2已经是最大的单张了
return(cardHands);
}
// 找一个较大的单张
for (var newBombSuitID = bombCardRankID + 1; newBombSuitID < (int)pokerface.CardID.JOB / 4; newBombSuitID++)
{
if (slots[newBombSuitID] > 0)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Single;
cardHand.cards.AddRange(extractCardByRank(hands, newBombSuitID, 1));
cardHands.Add(cardHand);
}
}
// 自己有2，那就是最大
if (slots[0] > 0)
{
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Single;
cardHand.cards.AddRange(extractCardByRank(hands, 0, 1));
cardHands.Add(cardHand);
}
return(cardHands);
}
/// <summary>
/// 根据牌列表，构造MsgCardHand对象
/// </summary>
/// <param name="hai">手牌列表</param>
/// <returns>如果牌列表是一个有效的组合，则返回一个MsgCardHand对象，否则返回null</returns>
public static MsgCardHand agariConvertMsgCardHand(int[] hai)
{
var key = calcKey(hai);
if (!agariTable.ContainsKey(key))
{
return(null);
}
var agari = agariTable[key];
var ct = (CardHandType)(agari & 0x0f);
var msgCardhand = new MsgCardHand();
msgCardhand.CardHandType = (int)ct;
// 排序，让大的牌在前面
Array.Sort(hai, (x, y) =>
{
return(y - x);
});
var cardsNew = new List <int>();
switch (ct)
{
case CardHandType.Flush:
cardsNew.AddRange(hai);
// 对于ACE需要特殊考虑，如果ACE作为类似于12345这样的顺子
var isAceSmallest = ((agari & 0x0100) != 0);
if (isAceSmallest)
{
var swp = cardsNew[0];
cardsNew.RemoveAt(0);
cardsNew.Add(swp);
}
break;
//case CardHandType.TripletPair:
//case CardHandType.Triplet2X2Pair:
// 确保3张在前面，对子在后面
//for (var i = 0; i < hai.Length; i++)
//{
// var h = hai[i];
// if (slots[h/4] == 3)
// {
// cardsNew.Add(h);
// }
//}
//for (var i = 0; i < hai.Length; i++)
//{
// var h = hai[i];
// if (slots[h / 4] != 3)
// {
// cardsNew.Add(h);
// }
//}
break;
default:
cardsNew.AddRange(hai);
break;
}
msgCardhand.Cards.AddRange(cardsNew);
// 如果是3个3，而且不包含红桃3，则把牌组改为炸弹，而不是三张
//if (ct == CardHandType.Triplet && msgCardhand.cards[0]/4 == (int)CardID.R3H/4)
//{
// var foundR3H = false;
// foreach (var c in msgCardhand.cards)
// {
// if (c == (int)CardID.R3H)
// {
// foundR3H = true;
// break;
// }
// }
// if (!foundR3H)
// {
// msgCardhand.cardHandType = (int)CardHandType.Bomb;
// }
//}
return(msgCardhand);
}
/// <summary>
/// 寻找所有大于上一手"3张+对子"的有效组合
/// </summary>
/// <param name="prev">上一手牌</param>
/// <param name="hands">手上的所有牌</param>
/// <returns>返回一个牌组列表，如果没有有效牌组，该列表长度为0</returns>
private static List <MsgCardHand> FindTripletPairGreatThan(MsgCardHand prev, List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
var flushLen = prev.cards.Count - 2;// 减去对子
var bombCardRankID = prev.cards[0] / 4;
var seqLength = flushLen / 3;
for (var newBombSuitID = bombCardRankID + 1; newBombSuitID <= (int)pokerface.CardID.AH / 4;)
{
var testBombRankID = newBombSuitID;
var found = true;
for (var i = 0; i < seqLength; i++)
{
if (slots[testBombRankID - i] < 3)
{
newBombSuitID = newBombSuitID + 1;
found = false;
break;
}
}
// 找到了
if (found)
{
var left = newBombSuitID + 1 - seqLength;
var right = newBombSuitID;
var pairCount = 0;
List <int> pairAble = new List <int>();
for (var testPair = 0; testPair < left; testPair++)
{
if (slots[testPair] > 1)
{
pairCount++;
pairAble.Add(testPair);
}
}
for (var testPair = right + 1; testPair < (int)pokerface.CardID.JOB / 4; testPair++)
{
if (slots[testPair] > 1)
{
pairCount++;
pairAble.Add(testPair);
}
}
if (pairCount > 0)
{
// 此处不再遍历各个对子
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.TripletPair;
cardHand.cards.AddRange(extractCardByRank(hands, left, 3));
cardHand.cards.AddRange(extractCardByRank(hands, pairAble[0], 2));
cardHands.Add(cardHand);
}
newBombSuitID = newBombSuitID + 1;
}
}
return(cardHands);
}
/// <summary>
/// 寻找比上一手牌大的所有有效牌组
/// 这个主要用于自动打牌以及给出提示之类
/// </summary>
/// <param name="prev">上一手牌</param>
/// <param name="hands">当前手上所有的牌</param>
/// <returns>返回一个牌组列表，如果没有有效牌组，该列表长度为0</returns>
public static List <pokerface.MsgCardHand> FindGreatThanCardHand(pokerface.MsgCardHand prev, List <int> hands, int specialCardID)
{
var prevCT = (pokerface.CardHandType)prev.cardHandType;
bool isBomb = false;
List <pokerface.MsgCardHand> tt = null;
if (specialCardID >= 0)
{
tt = new List <MsgCardHand>();
var cardHand = new MsgCardHand();
cardHand.cardHandType = (int)pokerface.CardHandType.Single;
cardHand.cards.AddRange(extractCardByRank(hands, 0, 1));
tt.Add(cardHand);
return(tt);
}
switch (prevCT)
{
case pokerface.CardHandType.Bomb:
tt = FindBombGreatThan(prev, hands);
isBomb = true;
break;
case pokerface.CardHandType.Flush:
tt = FindFlushGreatThan(prev, hands);
break;
case pokerface.CardHandType.Single:
tt = FindSingleGreatThan(prev, hands);
break;
case pokerface.CardHandType.Pair:
tt = FindPairGreatThan(prev, hands);
break;
case pokerface.CardHandType.Pair2X:
tt = FindPair2XGreatThan(prev, hands);
break;
case pokerface.CardHandType.Triplet:
tt = FindTripletGreatThan(prev, hands);
break;
case pokerface.CardHandType.Triplet2X:
tt = FindTriplet2XGreatThan(prev, hands);
break;
case pokerface.CardHandType.Triplet2X2Pair:
tt = FindTriplet2X2PairGreatThan(prev, hands);
break;
case pokerface.CardHandType.TripletPair:
tt = FindTripletPairGreatThan(prev, hands);
break;
}
if (!isBomb)
{
var tt2 = FindBomb(hands);
tt.AddRange(tt2);
}
return(tt);
}
private static List <MsgCardHand> SearchLongestTriplet2XOrTriplet2X2Pair(List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
for (var newBombSuitID = 0; newBombSuitID <= (int)pokerface.CardID.AH / 4;)
{
var testBombRankID = newBombSuitID;
for (var i = 0; i < 13; i++)
{
if (slots[testBombRankID + i] < 3)
{
// 找到了
if (i >= 2)
{
var cardHand = new MsgCardHand();
cardHand.cards.AddRange(extractCardByRanks(hands, testBombRankID, testBombRankID + i - 1, 3));
cardHands.Add(cardHand);
// 寻找2个对子
var left = testBombRankID;
var right = testBombRankID + i - 1;
var pairCount = 0;
List <int> pairAble = new List <int>();
for (var testPair = 0; testPair < left; testPair++)
{
if (slots[testPair] > 1)
{
pairCount++;
pairAble.Add(testPair);
}
}
for (var testPair = right + 1; testPair < (int)pokerface.CardID.JOB / 4; testPair++)
{
if (slots[testPair] > 1)
{
pairCount++;
pairAble.Add(testPair);
}
}
if (pairCount >= i)
{
// 此处不在遍历各种对子组合
var addPairCount = 0;
foreach (var pp in pairAble)
{
cardHand.cards.AddRange(extractCardByRank(hands, pp, 2));
addPairCount++;
if (addPairCount == i)
{
break;
}
}
}
}
break;
}
}
newBombSuitID = newBombSuitID + 1;
}
return(cardHands);
}
private static List <MsgCardHand> SearchUseableTripletOrTripletPair(List <int> hands)
{
List <MsgCardHand> cardHands = new List <MsgCardHand>();
ResetSlots(hands);
for (var newBombSuitID = 0; newBombSuitID <= (int)pokerface.CardID.AH / 4;)
{
var testBombRankID = newBombSuitID;
var found = true;
for (var i = 0; i < 1; i++)
{
if (slots[testBombRankID - i] < 3)
{
newBombSuitID = newBombSuitID + 1;
found = false;
break;
}
}
// 找到了
if (found)
{
var cardHand = new MsgCardHand();
cardHand.cards.AddRange(extractCardByRank(hands, newBombSuitID, 3));
cardHands.Add(cardHand);
var left = newBombSuitID;
var right = newBombSuitID;
var pairCount = 0;
List <int> pairAble = new List <int>();
for (var testPair = 0; testPair < left; testPair++)
{
if (slots[testPair] > 1)
{
pairCount++;
pairAble.Add(testPair);
}
}
for (var testPair = right + 1; testPair < (int)pokerface.CardID.JOB / 4; testPair++)
{
if (slots[testPair] > 1)
{
pairCount++;
pairAble.Add(testPair);
}
}
if (pairCount > 0)
{
// 此处不再遍历各个对子
cardHand.cards.AddRange(extractCardByRank(hands, pairAble[0], 2));
}
newBombSuitID = newBombSuitID + 1;
}
}
return(cardHands);
}