protected override int CompareWithSame(IPokerHand other)
{
var result = CompareHandMaxRank(other);
if (result == 0)
{
result = HandCards.Min(x => x.Rank).CompareTo(other.HandCards.Min(x => x.Rank));
}
if (result == 0)
{
result = CompareKickers(other);
}
return(result);
}
public void SecondRoundStarted(PokerCard card)
{
if (!IsInGame())
{
return;
}
BetedCoins = 0;
HandCards.Add(card);
Combination.SetCards(HandCards);
if (Status != SeatStatus.Drop && Status != SeatStatus.AllIn)
{
Status = SeatStatus.None;
}
}
public void TestAddAndRemoveHandCards()
{
HandCards dealerHandCards = new HandCards(0);
bool isSoftValue;
Assert.AreEqual(11, dealerHandCards.GetHandValue(out isSoftValue));
Assert.IsTrue(isSoftValue);
dealerHandCards = new HandCards(8);
Assert.AreEqual("9", dealerHandCards.ToString());
Assert.AreEqual(9, dealerHandCards.GetHandValue(out isSoftValue));
dealerHandCards.AddCard(3);
Assert.AreEqual("94", dealerHandCards.ToString());
Assert.AreEqual(13, dealerHandCards.GetHandValue(out isSoftValue));
Assert.IsFalse(isSoftValue);
Assert.AreEqual(3, dealerHandCards.ReverseAdd());
Assert.AreEqual(8, dealerHandCards.ReverseAdd());
Assert.AreEqual(-1, dealerHandCards.ReverseAdd()); // no card on hand
Assert.AreEqual(string.Empty, dealerHandCards.ToString());
// Soft 17
dealerHandCards.AddCard(5);
dealerHandCards.AddCard(0);
Assert.AreEqual("6A", dealerHandCards.ToString());
Assert.AreEqual(17, dealerHandCards.GetHandValue(out isSoftValue));
Assert.IsTrue(isSoftValue);
// Hard 17
dealerHandCards.AddCard(12);
Assert.AreEqual("6AK", dealerHandCards.ToString());
Assert.AreEqual(17, dealerHandCards.GetHandValue(out isSoftValue));
Assert.IsFalse(isSoftValue);
// Black Jack
dealerHandCards = new HandCards(10, 0);
Assert.AreEqual("JA", dealerHandCards.ToString());
Assert.AreEqual(21, dealerHandCards.GetHandValue(out isSoftValue));
Assert.IsTrue(isSoftValue);
Assert.IsTrue(dealerHandCards.IsBlackJack);
// Hard 21
dealerHandCards = new HandCards(11, 9);
dealerHandCards.AddCard(0);
Assert.AreEqual("QTA", dealerHandCards.ToString());
Assert.AreEqual(21, dealerHandCards.GetHandValue(out isSoftValue));
Assert.IsFalse(isSoftValue);
Assert.IsFalse(dealerHandCards.IsBlackJack);
}
protected void ThrowBase(ThrowResult result, Sequence animSeq = null,
Vector2?meetPoint = null)
{
AudioManager.I.PlayIfSilent(throwClip);
animSeq ??= DOTween.Sequence();
var card = HandCards.First(c => c.Front != null && c.Front.Index == result.ThrownCard);
Ground.I.Throw(card, result.EatenCardsIds, animSeq, meetPoint);
var count = result.EatenCardsIds?.Count ?? 0;
HandCards.Remove(card);
OrganizeHand();
CoreGameplay.I.NextTurn();
}
public void CheckGameResult(int betAmount, int[] p1CardNo, string[] p1CardSymbol, int[] p2CardNo, string[] p2CardSymbol, int expectResult)
{
var sut = new Pokdeng();
var p1HandCards = new HandCards();
var p2HandCards = new HandCards();
p1HandCards.CardNo = p1CardNo;
p2HandCards.CardNo = p2CardNo;
p1HandCards.CardSymbol = p1CardSymbol;
p2HandCards.CardSymbol = p2CardSymbol;
var p1SuitCards = sut.CheckSuitCards(p1HandCards);
var p2SuitCards = sut.CheckSuitCards(p2HandCards);
var result = sut.ReturnResult(betAmount, p1SuitCards, p2SuitCards);
Assert.Equal(expectResult, result);
}
public void CheckWinner(int[] p1CardNo, string[] p1CardSymbol, int[] p2CardNo, string[] p2CardSymbol, string expectWinner)
{
var sut = new Pokdeng();
var p1HandCards = new HandCards();
var p2HandCards = new HandCards();
p1HandCards.CardNo = p1CardNo;
p2HandCards.CardNo = p2CardNo;
p1HandCards.CardSymbol = p1CardSymbol;
p2HandCards.CardSymbol = p2CardSymbol;
var p1SuitCards = sut.CheckSuitCards(p1HandCards);
var p2SuitCards = sut.CheckSuitCards(p2HandCards);
var result = sut.IsWinner(p1SuitCards, p2SuitCards);
Assert.Equal(expectWinner, result);
}
public static bool IsSameCardsNumber(this HandCards handCardsA, HandCards handCardsB)
{
var a = handCardsA.Cards.OrderByDescending(x => x.CardNumber.GetNumber()).ToList();
var b = handCardsB.Cards.OrderByDescending(x => x.CardNumber.GetNumber()).ToList();
for (var i = 0; i < CardCount; i++)
{
if (!handCardsA.Cards[i].CardNumber.Number.Equals(handCardsB.Cards[i].CardNumber.Number))
{
return(false);
}
}
return(true);
}
/// <summary>
/// 发牌
/// </summary>
/// <param name="person"></param>
void DealTo(CharacterType person)
{
if (person == CharacterType.Desk)
{
Card movedCard = Deck.Instance.Deal();
DeskCardsCache.Instance.AddCard(movedCard);
}
else
{
GameObject playerObj = GameObject.Find(person.ToString());
HandCards cards = playerObj.GetComponent <HandCards>();
Card movedCard = Deck.Instance.Deal();
cards.AddCard(movedCard);
}
}
protected void RemoveCards(List <Card> cards)
{
HandCards allCards = gameObject.GetComponent <HandCards>();
for (int j = 0; j < cards.Count; j++)
{
for (int i = 0; i < allCards.CardsCount; i++)
{
if (cards[j] == allCards[i])
{
allCards.PopCard(cards[j]);
break;
}
}
}
}
public void SwapCard(Card handCard, Card deckCard)
{
var handIndex = HandCards.IndexOf(handCard);
HandCards.Remove(handCard);
HandCards.Insert(handIndex, deckCard);
var deckIndex = DeckCards.IndexOf(deckCard);
DeckCards.Remove(deckCard);
DeckCards.Insert(deckIndex, handCard);
IsSwapped[handIndex] = !IsSwapped[handIndex];
RefreshCards();
}
/// <summary>
/// 统计积分
/// </summary>
/// <param name="type"></param>
/// <param name="winner"></param>
void StatisticalIntegral(CharacterType type, Identity winner)
{
//积分计算
HandCards cards = GameObject.Find(type.ToString()).GetComponent <HandCards>();
int integration = cards.Multiples * Multiples * basePointPerMatch * (int)(cards.AccessIdentity + 1);
if (cards.AccessIdentity != winner)
{
integration = -integration;
}
cards.Integration = cards.Integration + integration;
//更新显示
UpdateIntegration(type);
}
public void Init()
{
Players.Clear();
SelectedCards.Clear();
HandCards.Clear();
CurrentDiscards.Clear();
BaseCards.Clear();
CurrentStatus = GameStatus.CallLandlord;
ClaimCount = 4;
CurrentTurn = 0;
RestCardNum = 17;
Mutiple = 1;
CurrentMode = GameMode.MutiPlayer;
LastPlayer = "";
Landlord = "";
BaseScore = 1000;
}
/// <summary>
/// 场上的所有牌回到牌库中
/// </summary>
public void BackToDeck()
{
HandCards[] handCards = new HandCards[3];
handCards[0] = GameObject.Find("Player").GetComponent <HandCards>();
handCards[1] = GameObject.Find("ComputerOne").GetComponent <HandCards>();
handCards[2] = GameObject.Find("ComputerTwo").GetComponent <HandCards>();
for (int i = 0; i < handCards.Length; i++)
{
while (handCards[i].CardsCount != 0)
{
Card last = handCards[i][handCards[i].CardsCount - 1];
Deck.Instance.AddCard(last);
handCards[i].PopCard(last);
}
}
}
public override bool IsPresent()
{
var set = new Set();
var pairSet = new OnePair();
set.SetCards(Cards.ToList());
pairSet.SetCards(Cards.ToList());
var isPresent = set.IsPresent() && pairSet.IsPresent();
if (isPresent)
{
HandCards.AddRange(set.HandCards);
HandCards.AddRange(pairSet.HandCards);
}
return(isPresent);
}
public override bool IsPresent()
{
var ordered = Cards.Select(x => x.Rank.Score).ToList();
if (ordered.Contains(Rank.Ace.Score))
{
ordered.Add(1);
}
ordered = ordered.OrderBy(x => x).ToList();
var countInOrder = 1;
var previousScore = ordered[0];
HandCards.Add(GetCard(previousScore));
for (int i = 1; i < ordered.Count; i++)
{
var score = ordered[i];
if (score == previousScore + 1)
{
countInOrder += 1;
HandCards.Add(GetCard(score));
if (countInOrder > 5)
{
HandCards.RemoveAt(0);
}
}
else if (score == previousScore)
{
continue;
}
else
{
if (countInOrder >= 5)
{
return(true);
}
HandCards.Clear();
HandCards.Add(GetCard(score));
countInOrder = 1;
}
previousScore = score;
}
return(countInOrder >= 5);
}
public void AddEventByPlayerAction(
PlayerAction playerAction,
int playerId,
HandCards dealerCards,
PlayerHandCards playerCards,
GameContext gameContext)
{
this.GameEvents.Add(
new GameEvent(
this.GameEvents.Count + 1,
GameEventType.PlayerAction,
string.Format(
GenericActionMessageTemplate,
"Player" + playerId,
playerAction.ToString().ToLower(),
dealerCards,
playerCards,
playerCards.BetAmount)));
}
public void AddCloseHandEvent(
int playerId,
HandCards dealerCards,
PlayerHandCards playerCards,
decimal winAmount,
string overrideResult = null)
{
this.GameEvents.Add(
new GameEvent(
this.GameEvents.Count + 1,
GameEventType.HandClosed,
string.Format(
CloseHandMessageTemplate,
"Player" + playerId,
dealerCards,
playerCards,
string.IsNullOrEmpty(overrideResult) ? GetResultByAmount(winAmount) : overrideResult,
winAmount)));
}
public override bool IsPresent()
{
var pairs = Cards.OrderByDescending(c => c.Rank).GroupBy(x => x.Rank).Where(g => g.Count() == 2);
if (pairs.Count() >= 2)
{
int count = 0;
foreach (var pair in pairs)
{
count++;
if (count <= 2)
{
HandCards.AddRange(pair);
}
}
}
return(pairs.Count() >= 2);
}
/// <summary>
/// 重连
/// </summary>
/// <param name="data"></param>
/// <param name="lastIn"></param>
/// <param name="isCurrent"></param>
public virtual void OnReJoin(ISFSObject data)
{
#region Data
ISFSArray Groups;
int[] OutCards;
int[] HandCards;
int HandNum;
bool hasTing;
GameTools.TryGetValueWitheKey(data, out Groups, RequestKey.KeyGroups);
GameTools.TryGetValueWitheKey(data, out OutCards, RequestKey.KeyOutCards);
GameTools.TryGetValueWitheKey(data, out HandCards, RequestKey.KeyHandCards);
GameTools.TryGetValueWitheKey(data, out HandNum, RequestKey.KeyHandCardsNum);
GameTools.TryGetValueWitheKey(data, out hasTing, RequestKey.KeyHasTing);
HasTing = hasTing;
GroupItems = new List <MahjongGroupData>();
ThrowOutCards = new List <int>();
GroupItems.AddRange(GameTools.GetGroupData(Groups));
ThrowOutCards.AddRange(OutCards.ToList());
if (HandCards.Length.Equals(0))
{
HandCards = new int[HandNum];
}
HandCardList = HandCards.ToList();
#endregion
#region UI
MahjongEnv.AddOutCards(ThrowOutCards);
for (int i = 0, lenth = GroupItems.Count; i < lenth; i++)
{
MahjongEnv.AddGroup(GroupItems[i], null, IsOther);
}
AddHandCards(HandCardList);
if (hasTing)
{
ShowTingWithEffect(false);
}
#endregion
}
/// <summary>
/// 点数計算
/// </summary>
public void CaluculatePoints()
{
var aces = HandCards.Where(card => card.Number == 1);
if (aces.Any())
{
//Aの初期化
aces.ToList().ForEach(ace => ace.BlackJackNumber = ace.Number);
var firstAceCard = aces.First();
var differenceOfBlackJackNumber
= BlackJackPoints - (HandCards.Sum(card => card.BlackJackNumber) - firstAceCard.BlackJackNumber);
if (firstAceCard.SpecialAcePoint <= differenceOfBlackJackNumber)
{
firstAceCard.BlackJackNumber = firstAceCard.SpecialAcePoint;
}
}
Points = HandCards.Sum(card => card.BlackJackNumber);
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
int hashCode = 41;
// Suitable nullity checks etc, of course :)
hashCode = hashCode * 59 + Direction.GetHashCode();
if (Name != null)
{
hashCode = hashCode * 59 + Name.GetHashCode();
}
hashCode = hashCode * 59 + Id.GetHashCode();
if (Location != null)
{
hashCode = hashCode * 59 + Location.GetHashCode();
}
hashCode = hashCode * 59 + EnergyCubes.GetHashCode();
hashCode = hashCode * 59 + Health.GetHashCode();
hashCode = hashCode * 59 + Active.GetHashCode();
hashCode = hashCode * 59 + Virtual.GetHashCode();
hashCode = hashCode * 59 + Priority.GetHashCode();
hashCode = hashCode * 59 + OnTurn.GetHashCode();
hashCode = hashCode * 59 + IsMine.GetHashCode();
hashCode = hashCode * 59 + HandCards.GetHashCode();
hashCode = hashCode * 59 + Attitude.GetHashCode();
hashCode = hashCode * 59 + Type.GetHashCode();
return(hashCode);
}
}
public static bool IsBiggerThanCards(this HandCards cardsA, HandCards cardsB)
{
var a = cardsA.Cards.OrderByDescending(x => x.CardNumber.GetNumber()).ToList();
var b = cardsB.Cards.OrderByDescending(x => x.CardNumber.GetNumber()).ToList();
for (var i = 0; i < CardCount; i++)
{
if (a[i].IsBiggerThan(b[i]))
{
return(true);
}
if (b[i].IsBiggerThan(a[i]))
{
return(false);
}
}
return(false);
}
private void DistributeAnim()
{
HandCards.ForEach(c =>
c.transform.position = Vector2.Lerp(startCard.position, endCard.position, .5f));
//the start anim position
var pointer = startCard.localPosition;
var handSize = endCard.localPosition.x - startCard.localPosition.x;
var spacing = new Vector3(handSize / (HandCards.Count - 1), 0, .05f);
foreach (var card in HandCards)
{
card.transform.DOScale(Vector3.one, .7f);
card.transform.DOLocalMove(pointer, .5f);
card.transform.DORotate(
new Vector3(0, 180, Random.Range(-Card.RotBound, Card.RotBound)), .3f);
pointer += spacing;
}
}
public void UserChupai()
{
HandCards player = GameObject.Find("Player").GetComponent <HandCards>();
//如果符合将牌从手牌移到出牌缓存区
DeskCardsCache.Instance.Clear();
DeskCardsCache.Instance.Rule = 0;
for (int i = 0; i < selectedSpriteList.Count; i++)
{
//先进行卡牌移动
player.PopCard(selectedSpriteList[i].Poker);
DeskCardsCache.Instance.AddCard(selectedSpriteList[i].Poker);
selectedSpriteList[i].transform.SetParent(GameObject.Find("Desk").transform);
}
DeskCardsCache.Instance.Sort();
GameController.AdjustCardSpritsPosition(CharacterType.Desk);
GameController.AdjustCardSpritsPosition(CharacterType.Player);
GameController.UpdateLeftCardsCount(CharacterType.Player, player.CardsCount);
}
public GameResult EvaluateCardsWinner(HandCards blackHandCards, HandCards whiteHandCards)
{
var blackCardsType = blackHandCards.GetCardsType(_validators);
var whiteCardType = whiteHandCards.GetCardsType(_validators);
if (blackCardsType.Priority.Equals(whiteCardType.Priority))
{
if (blackHandCards.IsSameCardsNumber(whiteHandCards))
{
return(GameResult.Tie);
}
return(blackCardsType.IsBlackCardsBiggerThanWhiteCards(blackHandCards, whiteHandCards)
? GameResult.BlackWin
: GameResult.WhiteWin);
}
return(blackCardsType.Priority > whiteCardType.Priority
? GameResult.BlackWin
: GameResult.WhiteWin);
}
/// <summary>
/// 发底牌
/// </summary>
/// <param name="type"></param>
public void CardsOnTable(CharacterType type)
{
GameObject parentObj = GameObject.Find(type.ToString());
HandCards cards = parentObj.GetComponent <HandCards>();
cards.Multiples = 2;
CardSprite[] sprites = GameObject.Find("Desk").GetComponentsInChildren <CardSprite>();
for (int i = 0; i < sprites.Length; i++)
{
sprites[i].Destroy();
}
while (DeskCardsCache.Instance.CardsCount != 0)
{
Card card = DeskCardsCache.Instance.Deal();
cards.AddCard(card);
}
MakeHandCardsSprite(type, true);
//更新身份
UpdateIndentity(type, Identity.Landlord);
}
protected List <CardSprite> GetSprite(List <Card> cards)
{
HandCards t = gameObject.GetComponent <HandCards>();
CardSprite[] sprites = GameObject.Find(t.cType.ToString()).transform.Find("StartPoint").GetComponentsInChildren <CardSprite>();
List <CardSprite> selectedSpriteList = new List <CardSprite>();
for (int i = 0; i < sprites.Length; i++)
{
for (int j = 0; j < cards.Count; j++)
{
if (cards[j] == sprites[i].Poker)
{
selectedSpriteList.Add(sprites[i]);
break;
}
}
}
return(selectedSpriteList);
}
public override bool IsPresent()
{
var straight = new Straight();
straight.SetCards(Cards.ToList());
var isStraight = straight.IsPresent();
var flush = new Flush();
flush.SetCards(Cards.ToList());
var isFlush = flush.IsPresent();
if (!isFlush || !isStraight)
{
return(false);
}
var suit = flush.HandCards.Select(x => x.Suit).First();
var ranks = straight.HandCards.Select(x => x.Rank).ToArray();
var handCards = straight.Cards.Where(x => ranks.Contains(x.Rank) && x.Suit == suit);
HandCards.AddRange(handCards);
return(HandCards.Count == 5);
}
protected void DiscardCards(List <Card> selectedCardsList, List <CardSprite> selectedSpriteList)
{
Card[] selectedCardsArray = selectedCardsList.ToArray();
//检测是否符合出牌规则
CardsType type;
if (CardRules.PopEnable(selectedCardsArray, out type))
{
HandCards player = gameObject.GetComponent <HandCards>();
//如果符合将牌从手牌移到出牌缓存区
DeskCardsCache.Instance.Clear();
DeskCardsCache.Instance.Rule = type;
for (int i = 0; i < selectedSpriteList.Count; i++)
{
DeskCardsCache.Instance.AddCard(selectedSpriteList[i].Poker);
selectedSpriteList[i].transform.parent = GameObject.Find("Desk").transform.Find("StartPoint");
selectedSpriteList[i].Poker = selectedSpriteList[i].Poker;
}
DeskCardsCache.Instance.Sort();
GameController.AdjustCardSpritsPosition(CharacterType.Desk);
GameController.AdjustCardSpritsPosition(player.cType);
GameController.UpdateLeftCardsCount(player.cType, player.CardsCount);
if (player.CardsCount == 0)
{
Debug.Log("Game OVer!");
//GameObject.Find("GameController").GetComponent<GameController>().GameOver();
}
else
{
OrderController.Instance.Biggest = player.cType;
OrderController.Instance.Turn();
}
}
}
public bool IsBlackCardsBiggerThanWhiteCards(HandCards blackHandCards, HandCards whiteHandCards)
{
var blackList = blackHandCards.Cards.GroupBy(x => x.CardNumber.GetNumber())
.Select(g => new { Number = g.Key, Count = g.Count() }).OrderBy(x => x.Number).Select(x => x.Number)
.ToList();
var blackMaxPair = blackList[1];
var blackMinPair = blackList[0];
var whiteList = blackHandCards.Cards.GroupBy(x => x.CardNumber.GetNumber())
.Select(g => new { Number = g.Key, Count = g.Count() }).OrderBy(x => x.Number).Select(x => x.Number)
.ToList();
var whiteMaxPair = whiteList[1];
var whiteMinPair = whiteList[0];
if (blackMaxPair == whiteMaxPair)
{
return(blackMinPair > whiteMinPair);
}
return(blackMaxPair > whiteMaxPair);
}
