public void Inits(List <Card> cards)
{
CardsType cardsType = CardsType.None;
CardRules.PopEnable(cards.ToArray(), out cardsType);
Layout(cardsType, cards);
}
// 找出指定種類的牌
public static List <List <Card> > FindAllCard(CardsType type, List <Card> deck)
{
List <List <Card> > cards = new List <List <Card> >();
switch (type)
{
case CardsType.None:
return(cards);
case CardsType.Single:
return(FindSingle(deck));
case CardsType.Pair:
return(FindPair(deck));
case CardsType.ThreeOfKinds:
return(FindThreeOfKinds(deck));
case CardsType.Straight:
return(FindStraight(deck));
case CardsType.FullHouse:
return(FindFullHouse(deck));
}
return(cards);
}
/// <summary>
/// 计算确定的牌型MatchCardFacesInfo
/// </summary>
/// <returns></returns>
public MatchCardFacesInfo ComputeMatchCardFacesInfo(CardFace[] cardFaces, CardsType cardsType = CardsType.None)
{
CardFace[] computedCardFaces = ComputeCardFaces(cardFaces, ref cardsType);
CardFace[] laiziCardFaces = new CardFace[computedCardFaces.Length];
int idx;
CardFace[] removeLaizi = new CardFace[1];
for (int i = 0; i < computedCardFaces.Length; i++)
{
idx = CardsTransform.Instance.FindCardFace(cardFaces, computedCardFaces[i]);
if (idx != -1)
{
laiziCardFaces[i] = cardFaces[idx];
cardFaces = CardsTransform.Instance.CreateDelFaceValues(cardFaces, new CardFace[] { cardFaces[idx] });
}
else
{
cardFaces = CardsTransform.Instance.RemoveLaiziByCount(cardFaces, laizi, 1, removeLaizi);
laiziCardFaces[i] = removeLaizi[0];
}
}
MatchCardFacesInfo matchInfo = new MatchCardFacesInfo()
{
computedCardFaces = computedCardFaces,
laiziCardFaces = laiziCardFaces,
type = cardsType
};
return(matchInfo);
}
//上一轮为三不带的出牌逻辑
public static bool isOnlyThreeCompare(Card[] card1, Card[] card2, CardsType type1, CardsType type2)
{
if (type1 == CardsType.OnlyThree)
{
if (type2 == CardsType.OnlyThree)
{
if (card2[0].GetCardWeight > card1[0].GetCardWeight)
{
return(true);
}
else
{
return(false);
}
}
else if (type2 == CardsType.Boom || type2 == CardsType.JokerBoom)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
/// <summary>
/// 获取指定数组的权值
/// </summary>
/// <param name="cards"></param>
/// <param name="rule"></param>
/// <returns></returns>
public static int GetWeight(Card[] cards, CardsType rule)
{
int totalWeight = 0;
if (rule == CardsType.ThreeAndOne || rule == CardsType.ThreeAndTwo)
{
for (int i = 0; i < cards.Length; i++)
{
if (i < cards.Length - 2)
{
if (cards[i].GetCardWeight == cards[i + 1].GetCardWeight &&
cards[i].GetCardWeight == cards[i + 2].GetCardWeight)
{
totalWeight += (int)cards[i].GetCardWeight;
totalWeight *= 3;
break;
}
}
}
}
else
{
for (int i = 0; i < cards.Length; i++)
{
totalWeight += (int)cards[i].GetCardWeight;
}
}
return(totalWeight);
}
/// <summary>
/// 玩家出牌
/// </summary>
/// <param name="selectedCardsList"></param>
/// <param name="selectedSpriteList"></param>
void PlayCards(CardsType type)
{
//如果符合将牌从手牌移到出牌缓存区
DeskCardsCache.Instance.Clear();
DeskCardsCache.Instance.Rule = type;
for (int i = 0; i < selectedCardsList.Count; i++)
{
//先进行卡牌移动
player.PopCard(selectedCardsList[i]);
DeskCardsCache.Instance.AddCard(selectedCardsList[i]);
}
ChangeRatio(type);
PlayAniByCarsType(type);
//临时try
try
{
PlaySound(type, (Weight)DeskCardsCache.Instance.MinWeight);
}
catch
{
}
DeskCardsCache.Instance.Sort();
if (player.CardsCount != 0)
{
OrderController.Instance.BiggestUid = player.playerInfo.uid;
}
}
//card1：上一轮的牌；card2：这一轮的牌
//上一轮为单支的出牌逻辑
public static bool isSingleCompare(Card[] card1, Card[] card2, CardsType type1, CardsType type2)
{
//CardsType type1;
//CardsRules.PopEnable(card1, out type1);
//CardsType type2;
//CardsRules.PopEnable(card2, out type2);
if (type1 == CardsType.Single)
{
if (type2 == CardsType.Single)
{
if (card2[0].GetCardWeight > card1[0].GetCardWeight)
{
return(true);
}
else
{
return(false);
}
}
else if (type2 == CardsType.Boom || type2 == CardsType.JokerBoom)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
// 檢查手上的牌組是否可以出牌
private static bool CheckSelectCardsCanPass(List <Card> selectCards)
{
// 判斷是否為第一手
if (TopCards.Count == 0)
{
// 確認第一手牌的合理性
if (!CheckFirstHandsReasonably(selectCards))
{
return(false);
}
// 確認牌型的合理性
if (CheckCardType(selectCards) != CardsType.None)
{
return(true);
}
else
{
return(false);
}
}
/* 非第一手之後都走下面流程 */
// 判斷前三組是不是都pass
if (CheckAllPlayerPass())
{
if (CheckCardType(selectCards) != CardsType.None)
{
return(true);
}
else
{
return(false);
}
}
// 取得最後檯面上的牌
List <Card> LastCards = GetLastTableCards();
// 先確認檯面牌型
CardsType cardType = CheckCardType(LastCards);
// 5張以上直接不能出( 什麼牌型都不是 )
if (selectCards.Count > 5)
{
return(false);
}
// 是否為怪物牌
if (cardType > CardsType.FullHouse)
{
return(CheckMonsterCard(selectCards, LastCards, cardType));
}
else
{
// 不是怪物牌就用一般判斷
return(CheckNomalCard(selectCards, LastCards, cardType));
}
}
/// <summary>
/// 根据牌型播放动画
/// </summary>
void PlayAniByCarsType(CardsType type)
{
switch (type)
{
case CardsType.JokerBoom:
NodeManager.OpenNode <LandlordsEffectNode>(null, null, false).Inits(LandlordsEventAniType.JokerBoom, 0, 0, player.playerInfo.icon);
break;
case CardsType.Boom:
NodeManager.OpenNode <LandlordsEffectNode>(null, null, false).Inits(LandlordsEventAniType.Boom, 1, 0);
break;
case CardsType.Straight:
NodeManager.OpenNode <LandlordsEffectNode>(null, null, false).Inits(LandlordsEventAniType.Straight, 0, 0);
break;
case CardsType.DoubleStraight:
NodeManager.OpenNode <LandlordsEffectNode>(null, null, false).Inits(LandlordsEventAniType.DoubleStraight, 0, 0);
break;
case CardsType.TripleStraight:
case CardsType.TripleStraightDaiOne:
case CardsType.TripleStraightDaiTwo:
NodeManager.OpenNode <LandlordsEffectNode>(null, null, false).Inits(LandlordsEventAniType.Fly, 0, 0, player.playerInfo.icon);
break;
}
}
// 檢查怪物牌比較
private static bool CheckMonsterCard(List <Card> cards, List <Card> LastCard, CardsType cardType)
{
// 先看看自己手上有沒有怪物牌
// 如果我的怪物牌比場上怪物牌還大直接給過, 相同則需比較
if (CheckCardType(cards) > cardType)
{
return(true);
}
else
{
switch (cardType)
{
case CardsType.FourOfKinds:
if (CardTypeCheckMgr.IsFourOfKinds(cards) == CardsType.FourOfKinds)
{
return(CardTypeCheckMgr.compFourOfKinds(cards, LastCard));
}
return(false);
case CardsType.StraightFlush:
if (CardTypeCheckMgr.IsStraightFlush(cards) == CardsType.StraightFlush)
{
return(CardTypeCheckMgr.compStraightFlush(cards, LastCard));
}
return(false);
}
}
return(false);
}
/// <summary>
/// 播放音效
/// </summary>
/// <param name="type"></param>
/// <param name="?"></param>
/// <param name="weight"></param>
void PlaySound(CardsType type, Weight weight)
{
LandlordsModel.Instance.PlaySound(AudioManager.AudioSoundType.popCard);
AudioManager.AudioSoundType soundType = AudioManager.AudioSoundType.None;
if (type == CardsType.Single || type == CardsType.Double)
{
soundType = LandlordsSoundModel.PlayPlayerPopSound(player.playerInfo.uid, type, weight);
}
else
{
soundType = LandlordsSoundModel.PlayPlayerPopSound(player.playerInfo.uid, type);
}
LandlordsModel.Instance.PlaySound(soundType);
//就剩2张牌
if (player.CardsCount == 2)
{
AudioManager.Instance.PlayTempSound(AudioManager.AudioSoundType.warring, PageManager.Instance.CurrentPage.name);
LandlordsModel.Instance.PlaySound(player.Six == Six.boy ? AudioManager.AudioSoundType.boyTwocard : AudioManager.AudioSoundType.girlTwocard);
}
else if (player.CardsCount == 1)
{
LandlordsModel.Instance.PlaySound(player.Six == Six.boy ? AudioManager.AudioSoundType.boyOnecard : AudioManager.AudioSoundType.girlOnecard);
}
if (player.CardsCount <= 2 && player.CardsCount > 0)
{
LandlordsPage.Instance.LandlordsWarning(player.playerInfo.uid, player.CardsCount, true);
}
}
public void SaveCurrentCardsType(string cardTypeCode, List <int> keysOutside)
{
twp = new TypeWithPoints();
CardsType ct = (CardsType)Enum.Parse(typeof(CardsType), cardTypeCode);
twp.cardsType = ct;
switch (ct)
{
case CardsType.Single:
twp.p = keysOutside[0];
break;
case CardsType.Doub:
twp.p = keysOutside[0];
break;
case CardsType.Four:
twp.p = keysOutside[0];
break;
default:
twp.ps = keysOutside;
break;
}
}
/// <summary>
/// 改变出牌者，被管住了
/// </summary>
/// <param name="userId"></param>
/// <param name="cardsType"></param>
/// <param name="cardsLenght"></param>
/// <param name="cardsWeight"></param>
public void ChangeBiggestId(int userId, CardsType cardsType, int cardsLenght, CardWeight cardsWeight)
{
this.currentBiggsetId = userId;
this.lastCardsType = cardsType;
this.lastCardsLength = cardsLenght;
this.lastCardsWeight = cardsWeight;
}
//布局
void Layout(CardsType layoutType, List <Card> cards)
{
switch (layoutType)
{
case CardsType.OnlyThree:
case CardsType.ThreeAndOne:
case CardsType.ThreeAndTwo:
curParentTrans = angleDesk;
CreateCards(curParentTrans, cards, true);
AngleLayout(3);
break;
case CardsType.FourAndTwo:
curParentTrans = angleDesk;
CreateCards(curParentTrans, cards, true);
AngleLayout(4);
break;
default:
curParentTrans = normalDesk;
CreateCards(curParentTrans, cards, false);
NormalLayout();
break;
}
}
private void Init()
{
currentUserId = -1;
currentBiggsetId = -1;
lastCardsType = CardsType.None;
lastCardsLength = 0;
lastCardsWeight = 0;
}
/// <summary>
/// 开始出牌 设置完了地主之后 发了底牌就该出牌了
/// </summary>
/// <param name="userId"></param>
public void Start(int userId)
{
this.currentUserId = userId;
this.currentBiggsetId = userId;
lastCardsType = CardsType.None;
lastCardsLength = 0;
lastCardsWeight = 0;
}
/// <summary>
/// 检测玩家出牌
/// </summary>
bool CheckPlayCards(List <Card> selectedCardsLists, out CardsType type)
{
bool isCanPlayCard = false;
Card[] selectedCardsArray = selectedCardsLists.ToArray();
//检测是否符合出牌规则
//CardsType type;
if (CardRules.PopEnable(selectedCardsArray, out type))
{
CardsType rule = DeskCardsCache.Instance.Rule;
if (OrderController.Instance.BiggestUid == OrderController.Instance.TypeUid)
{
isCanPlayCard = true;
}
else if (DeskCardsCache.Instance.Rule == CardsType.None)
{
isCanPlayCard = true;
}
else if (type == rule && selectedCardsLists.Count == DeskCardsCache.Instance.CardsCount && LandlordsModel.Instance.GetWeight(selectedCardsArray, type) > DeskCardsCache.Instance.TotalWeight)
{
isCanPlayCard = true;
}
//飞机带1
else if (type == rule && type == CardsType.TripleStraightDaiOne)
{
if (selectedCardsLists.Count == DeskCardsCache.Instance.CardsCount && LandlordsModel.Instance.GetWeight(selectedCardsArray, type) > DeskCardsCache.Instance.TotalWeight)
{
isCanPlayCard = true;
}
}
//飞机带2
else if (type == rule && type == CardsType.TripleStraightDaiTwo)
{
if (selectedCardsLists.Count == DeskCardsCache.Instance.CardsCount && LandlordsModel.Instance.GetWeight(selectedCardsArray, type) > DeskCardsCache.Instance.TotalWeight)
{
isCanPlayCard = true;
}
}
//炸弹
else if (type == CardsType.Boom && rule != CardsType.Boom)
{
isCanPlayCard = true;
}
else if (type == CardsType.JokerBoom)
{
isCanPlayCard = true;
}
else if (type == CardsType.Boom && rule == CardsType.Boom &&
LandlordsModel.Instance.GetWeight(selectedCardsArray, type) > DeskCardsCache.Instance.TotalWeight)
{
isCanPlayCard = true;
}
}
return(isCanPlayCard);
}
public CardsType checkType(JsonData data)
{
CardsType type = DDZRules.instance.getCardsType(data);
if (type == CardsType.ErrType)
{
Debug.Log("checkType error type = -1");
}
return(type);
}
/// <summary>
/// 遍历选中的牌
/// </summary>
void CheckSelectCards()
{
//排好序
CardRules.SortCards(selectedCardsList, true);
CardsType type = CardsType.None;
//出牌
CheckPlayCards(selectedCardsList, out type);//这里不用判断能否出牌,因为selectedCardsList是服务器已经判断过能出的牌
PlayCards(type);
}
public void Set(int userId, List <CardDto> cards)
{
this.userId = userId;
this.cardsList = cards;
var typeWeight = cardsList.GetCardsTypeWeight();
this.type = typeWeight.type;
this.weight = typeWeight.weight;
this.length = cardsList.Count;
this.isLeagl = this.type != CardsType.None;
isBiggest = false;
}
private Cards GetRoundCards(XElement roundNode, CardsType cardsType)
{
var cardsText = string.Join(" ", roundNode.Descendants("Card").Select(x => x.Value).ToArray());
var cards = new Cards
{
Type = cardsType,
Player = string.Empty,
Value = cardsConverter.Convert(cardsText)
};
return(cards);
}
//查找牌型的牌比指定Level大的牌
protected int findMorethanLevel(CardsType type, int maxLev)
{
int local = -1;
for (int i = typeLevelsDic [type].Count - 1; i >= 0; i--)
{
if (typeLevelsDic [type][i] > lastMaxLev || typeLevelsDic [type][i] == 13)
{
local = i;
break;
}
}
return(local);
}
/// <summary>
/// 检测玩家出牌
/// </summary>
/// <param name="selectedCardsList"></param>
/// <param name="selectedSpriteList"></param>
bool CheckPlayCards(List <Card> selectedCardsList, List <CardSprite> selectedSpriteList)
{
GameController controller = GameObject.Find("GameController").GetComponent <GameController>();
Card[] selectedCardsArray = selectedCardsList.ToArray();
//检测是否符合出牌规则
CardsType type;
if (CardRules.PopEnable(selectedCardsArray, out type))
{
CardsType rule = DeskCardsCache.Instance.Rule;
if (OrderController.Instance.Biggest == OrderController.Instance.Type)
{
PlayCards(selectedCardsList, selectedSpriteList, type);
return(true);
}
else if (DeskCardsCache.Instance.Rule == CardsType.None)
{
PlayCards(selectedCardsList, selectedSpriteList, type);
return(true);
}
//炸弹
else if (type == CardsType.Boom && rule != CardsType.Boom)
{
controller.Multiples = 2;
PlayCards(selectedCardsList, selectedSpriteList, type);
return(true);
}
else if (type == CardsType.JokerBoom)
{
controller.Multiples = 4;
PlayCards(selectedCardsList, selectedSpriteList, type);
return(true);
}
else if (type == CardsType.Boom && rule == CardsType.Boom &&
GameController.GetWeight(selectedCardsArray, type) > DeskCardsCache.Instance.TotalWeight)
{
controller.Multiples = 2;
PlayCards(selectedCardsList, selectedSpriteList, type);
return(true);
}
else if (GameController.GetWeight(selectedCardsArray, type) > DeskCardsCache.Instance.TotalWeight)
{
PlayCards(selectedCardsList, selectedSpriteList, type);
return(true);
}
}
return(false);
}
public static AudioManager.AudioSoundType PlayPlayerPopSound(string uid, CardsType cardsType, Weight weight = Weight.Three)
{
LandkirdsHandCardModel playerHand = LandlordsModel.Instance.GetHandCardMode(uid);
if (playerHand != null)
{
string soundStr = playerHand.Six + cardsType.ToString();
if (cardsType == CardsType.Single || cardsType == CardsType.Double)
{
soundStr += weight;
}
return(GameTool.StrToEnum <AudioManager.AudioSoundType>(soundStr));
}
return(AudioManager.AudioSoundType.None);
}
/// <summary>
/// 主角是否能出牌
/// </summary>
public static bool IsCanPop(List <Card> cards)
{
//排好序
CardRules.SortCards(cards, true);
CardsType type = CardsType.None;
bool isCanPlayCard = PlayCard.Instance.CheckPlayCards(cards, out type);
if (!isCanPlayCard)
{
UIUtils.Log("不能大过场上的牌或者和场上的牌型不一致");
}
return(isCanPlayCard);
}
/// <summary>
/// 根据牌型改变倍率
/// </summary>
void ChangeRatio(CardsType type)
{
switch (type)
{
case CardsType.None:
break;
case CardsType.JokerBoom:
LandlordsPage.Instance.Multiples *= 2;
break;
case CardsType.Boom:
LandlordsPage.Instance.Multiples *= 2;
break;
}
}
public void GaoPaiTest()
{
List<Card> cardList = new List<Card>()
{
new Card(){Num=2,Hua=Color.D},
new Card(){Num=12,Hua=Color.S},
new Card(){Num=11,Hua=Color.B},
new Card(){Num=3,Hua=Color.A},
new Card(){Num=4,Hua=Color.S},
new Card(){Num=7,Hua=Color.B},
new Card(){Num=6,Hua=Color.D},
};
CardsType ct = new CardsType();
double weight = CardUtil.GetWeight(cardList, out ct);
Assert.AreEqual(ct, CardsType.GaoPai);
Assert.AreEqual(weight, 1.1211070604);
}
// 檢查非怪物牌比較
private static bool CheckNomalCard(List <Card> cards, List <Card> LastCards, CardsType cardType)
{
if (CheckCardType(cards) > CardsType.FullHouse) // 如果自身牌為怪物牌直接給過
{
return(true);
}
switch (cardType) // 不是的話另外判斷
{
case CardsType.Single:
if (CardTypeCheckMgr.IsSingle(cards) == CardsType.Single)
{
return(CardTypeCheckMgr.compSingle(cards[0], LastCards[0]));
}
return(false);
case CardsType.Pair:
if (CardTypeCheckMgr.IsPair(cards) == CardsType.Pair)
{
return(CardTypeCheckMgr.compPair(cards[cards.Count - 1], LastCards[LastCards.Count - 1]));
}
return(false);
case CardsType.ThreeOfKinds:
if (CardTypeCheckMgr.IsThreeOfKinds(cards) == CardsType.ThreeOfKinds)
{
return(CardTypeCheckMgr.compThreeOfKinds(cards[cards.Count - 1], LastCards[LastCards.Count - 1]));
}
return(false);
case CardsType.Straight:
if (CardTypeCheckMgr.IsStraight(cards) == CardsType.Straight)
{
return(CardTypeCheckMgr.compStraight(cards, LastCards));
}
return(false);
case CardsType.FullHouse:
if (CardTypeCheckMgr.IsFullHouse(cards) == CardsType.FullHouse)
{
return(CardTypeCheckMgr.compFullHouse(cards, LastCards));
}
return(false);
}
return(false);
}
public void ManTangHonTest()
{
List<Card> cardList = new List<Card>()
{
new Card(){Num=2,Hua=Color.D},
new Card(){Num=2,Hua=Color.S},
new Card(){Num=2,Hua=Color.B},
new Card(){Num=7,Hua=Color.A},
new Card(){Num=6,Hua=Color.S},
new Card(){Num=7,Hua=Color.B},
new Card(){Num=6,Hua=Color.D},
};
CardsType ct = new CardsType();
double weight = CardUtil.GetWeight(cardList, out ct);
Assert.AreEqual(ct, CardsType.ManTangHon);
Assert.AreEqual(weight, 7.0202020707);
}
public void SanTiaoTest()
{
List<Card> cardList = new List<Card>()
{
new Card(){Num=2,Hua=Color.D},
new Card(){Num=2,Hua=Color.S},
new Card(){Num=2,Hua=Color.B},
new Card(){Num=3,Hua=Color.A},
new Card(){Num=12,Hua=Color.S},
new Card(){Num=7,Hua=Color.B},
new Card(){Num=6,Hua=Color.D},
};
CardsType ct = new CardsType();
double weight = CardUtil.GetWeight(cardList, out ct);
Assert.AreEqual(ct, CardsType.SanTiao);
Assert.AreEqual(weight, 4.0202021207);
}
public void LiangDuiTest()
{
List<Card> cardList = new List<Card>()
{
new Card(){Num=2,Hua=Color.D},
new Card(){Num=2,Hua=Color.S},
new Card(){Num=3,Hua=Color.B},
new Card(){Num=8,Hua=Color.A},
new Card(){Num=6,Hua=Color.S},
new Card(){Num=7,Hua=Color.B},
new Card(){Num=6,Hua=Color.D},
};
CardsType ct = new CardsType();
double weight = CardUtil.GetWeight(cardList, out ct);
Assert.AreEqual(ct, CardsType.LiangDui);
Assert.AreEqual(weight, 3.0606020208);
}
static void Main(string[] args)
{
List<Card> cardList = new List<Card>()
{
new Card(){Num=2,Hua=Color.S},
new Card(){Num=3,Hua=Color.S},
new Card(){Num=3,Hua=Color.B},
new Card(){Num=11,Hua=Color.A},
new Card(){Num=6,Hua=Color.S},
new Card(){Num=7,Hua=Color.B},
new Card(){Num=6,Hua=Color.D},
};
CardsType ct = new CardsType();
double weight=CardUtil.GetWeight(cardList,out ct);
Console.WriteLine("CardType:{0}======Weight: {1} ",ct.ToString(),weight);
Console.Read();
}
/**
* 整个出牌判断
*/
public static bool isCanOutCard(Card[] card1, Card[] card2, CardsType type1, CardsType type2)
{
if (isSingleCompare(card1, card2, type1, type2))
{
return(true);
}
else if (isDoubleCompare(card1, card2, type1, type2))
{
return(true);
}
else if (isOnlyThreeCompare(card1, card2, type1, type2))
{
return(true);
}
else if (isThreeAndOneCompare(card1, card2, type1, type2))
{
return(true);
}
else if (isStraightCompare(card1, card2, type1, type2))
{
return(true);
}
else if (isDoubleStraightCompare(card1, card2, type1, type2))
{
return(true);
}
else if (isTripleStraightCompare(card1, card2, type1, type2))
{
return(true);
}
else if (isBoomCompare(card1, card2, type1, type2))
{
return(true);
}
else if (isJokerBoomCompare(card1, card2, type1, type2))
{
return(true);
}
else
{
return(false);
}
}
//上一轮为顺子的出牌逻辑
public static bool isStraightCompare(Card[] card1, Card[] card2, CardsType type1, CardsType type2)
{
if (type1 == CardsType.Straight)
{
if (type2 == CardsType.Straight)
{
//如果两者都是顺子，但是牌的数量不同
if (card1.Length != card2.Length)
{
return(false);
}
else
{
// isReasonable = true;
if (card2[0].GetCardWeight > card1[0].GetCardWeight)
{
return(true);
}
else
{
return(false);
}
}
}
else if (type2 == CardsType.Boom || type2 == CardsType.JokerBoom)
{
// isReasonable = true;
return(true);
}
else
{
// isReasonable = true;
return(false);
}
}
else
{
//isReasonable = true;
return(false);
}
}
public void Clear()
{
if (library.Count != 0)
{
CardSprite[] cardSprites = GameObject.Find("Desk").GetComponentsInChildren <CardSprite>();
for (int i = 0; i < cardSprites.Length; i++)
{
cardSprites[i].transform.parent = null;
cardSprites[i].Destroy();
}
while (library.Count != 0)
{
Card card = library[library.Count - 1];
library.Remove(card);
Deck.Instance.AddCard(card);
}
rule = CardsType.None;
}
}
public void ShunZiTest()
{
List<Card> cardList = new List<Card>()
{
new Card(){Num=2,Hua=Color.D},
new Card(){Num=3,Hua=Color.S},
new Card(){Num=4,Hua=Color.B},
new Card(){Num=5,Hua=Color.A},
new Card(){Num=6,Hua=Color.S},
new Card(){Num=7,Hua=Color.B},
new Card(){Num=6,Hua=Color.D},
};
CardsType ct = new CardsType();
double weight = CardUtil.GetWeight(cardList, out ct);
Assert.AreEqual(ct, CardsType.ShunZi);
Assert.AreEqual(weight, 5.0706050403);
}
public void TongHuaTest()
{
List<Card> cardList = new List<Card>()
{
new Card(){Num=6,Hua=Color.D},
new Card(){Num=2,Hua=Color.S},
new Card(){Num=9,Hua=Color.B},
new Card(){Num=2,Hua=Color.B},
new Card(){Num=11,Hua=Color.B},
new Card(){Num=7,Hua=Color.B},
new Card(){Num=6,Hua=Color.B},
};
CardsType ct = new CardsType();
double weight = CardUtil.GetWeight(cardList, out ct);
Assert.AreEqual(ct, CardsType.TongHua);
Assert.AreEqual(weight, 6.1109070602);
}
