public PokerCard DrawPokerCardBottom()
{
PokerCard chosen = pokerDeck.Last.Value;
pokerDeck.RemoveLast();
return(chosen);
}
public PokerCard DrawPokerCardTop()
{
PokerCard chosen = pokerDeck.First.Value;
pokerDeck.RemoveFirst();
return(chosen);
}
/// <summary>
/// 小盲注的位置索引
/// </summary>
//private int _smallD = 0;
#region 发手牌
/// <summary>
/// 发一张牌 有过程
/// </summary>
private GameObject DealOnes(Transform from, Transform to, int cardValue = 0, int index = 0)
{
GameObject gob = Instantiate(PokerPrefab);
gob.transform.parent = from;
gob.transform.localPosition = Vector3.zero;
PokerCard pCard = gob.GetComponent <PokerCard>();
pCard.SetCardDepth(100 + index * 2);
gob.transform.parent = to;
gob.GetComponent <PokerCard>().SetCardId(cardValue);
TweenPosition tp = gob.GetComponent <TweenPosition>();
tp.duration = 0.15f;//0.25f;
tp.from = gob.transform.localPosition;
tp.to = Vector3.zero;
tp.ResetToBeginning();
tp.PlayForward();
TweenScale ts = gob.GetComponent <TweenScale>();
ts.duration = 0.15f;
ts.from = Vector3.one * 0.3f;
ts.to = Vector3.one * 0.76f;
ts.ResetToBeginning();
ts.PlayForward();
return(gob);
}
public void CheckIsFlush()
{
PokerCard[] CommCards = new PokerCard[5];
CommCards[0] = new PokerCard(PokerCard.Cards.Four, PokerCard.Suits.Hearts);
CommCards[1] = new PokerCard(PokerCard.Cards.Two, PokerCard.Suits.Hearts);
CommCards[2] = new PokerCard(PokerCard.Cards.King, PokerCard.Suits.Hearts);
CommCards[3] = new PokerCard(PokerCard.Cards.Queeen, PokerCard.Suits.Spades);
CommCards[4] = new PokerCard(PokerCard.Cards.Ace, PokerCard.Suits.Spades);
PokerCard[] HoleCardsCheck = new PokerCard[2];
HoleCardsCheck[0] = new PokerCard(PokerCard.Cards.Jack, PokerCard.Suits.Hearts);
HoleCardsCheck[1] = new PokerCard(PokerCard.Cards.Ace, PokerCard.Suits.Hearts);
PokerHand HandCheck = new PokerHand(HoleCardsCheck, CommCards);
Assert.IsTrue(PokerRules.PokerRules.IsFlush(HandCheck, CommCards).Card == PokerCard.Cards.Ace);
Assert.IsTrue(PokerRules.PokerRules.IsFlush(HandCheck, CommCards).Suit == PokerCard.Suits.Hearts);
//Functional programming 1
Assert.IsTrue(PokerRules.PokerRules.IsFlushFnc1(HandCheck, CommCards).Card == PokerCard.Cards.Ace);
Assert.IsTrue(PokerRules.PokerRules.IsFlushFnc1(HandCheck, CommCards).Suit == PokerCard.Suits.Hearts);
//Functional programming 2
Assert.IsTrue(PokerRules.PokerRules.IsFlushFnc2(HandCheck, CommCards).Card == PokerCard.Cards.Ace);
Assert.IsTrue(PokerRules.PokerRules.IsFlushFnc2(HandCheck, CommCards).Suit == PokerCard.Suits.Hearts);
}
internal override void StartTableOk(int[] cardHand, Message msg, string[] nickPlay)
{
base.StartTableOk(cardHand, msg, nickPlay);
for (int i = 0; i < ListPlayer.Count; i++)
{
((LiengPlayer)ListPlayer[i]).MoneyChip = 0;
}
groupMoneyTo.OnHide();
MinToMoney = GameConfig.BetMoney * 2;
MaxToMoney = ClientConfig.UserInfo.CASH_FREE - MinToMoney;
SumChipControl.MoneyChip = 0;
tongMoney = 0;
//Debug.LogError("Card Hand " + cardHand.Length);
int[] ccc = new int[2];
int ii = 0;
for (int i = 0; i < cardHand.Length; i++)
{
//Debug.LogError("Card Hand i " + cardHand[i]);
if (cardHand[i] >= 0 && cardHand[i] < 52)
{
ccc[ii] = cardHand[i];
ii++;
}
}
list_my_card.Clear();
list_my_card.AddRange(ccc);
for (int i = 0; i < ListPlayer.Count; i++)
{
LiengPlayer player = (LiengPlayer)ListPlayer[i];
if (player != null)
{
player.MoneyChip = GameConfig.BetMoney;
player.MoveChip(GameConfig.BetMoney, SumChipControl.transform.position);
if (player.SitOnClient == 0)
{
player.CardHand.SetAllDark(true);
//player.SetTypeCard(PokerCard.getTypeOfCardsPoker(list_my_card.ToArray()));
//player.SetTypeCard(
TYPE_CARD type = TypeCardMauBinh.GetTypeCardMauBinh(list_my_card.ToArray());
int type2 = PokerCard.getTypeOfCardsPoker(list_my_card.ToArray());
//Debug.LogError("11111111111Type card: " + type);
//Debug.LogError("22222222222Type card: " + type2);
player.CardHand.ChiaBaiTienLen(ccc, true);
player.CardHand.SetTouchCardHand(true);
}
else
{
player.CardHand.ChiaBaiTienLen(new int[] { 52, 52 }, true);
}
}
tongMoney += GameConfig.BetMoney;
}
SumChipControl.OnShow();
SumChipControl.MoneyChip = tongMoney;
}
public int BestDealerMove(Hand hand, PokerCard topOfDeck)
{
for (int i = 0; i < 5; i++)
{
if (SameValueCheck(hand, i, topOfDeck) && !IsDiscarded(hand, i) && hand.GetaCard(i).GetCardValue() != 8)
{
return(i);
}
}
for (int i = 0; i < 5; i++)
{
if (SameSuitCheck(hand, i, topOfDeck) && !IsDiscarded(hand, i) && hand.GetaCard(i).GetCardValue() != 8)
{
return(i);
}
}
for (int i = 0; i < 5; i++)
{
if (Crazy8Check(hand, i) && !IsDiscarded(hand, i))
{
return(i);
}
}
return(5);
}
public void ChangedCard(PokerRoom room, string cardValue)
{
AssertContextUserJoinedRoom(room.Name);
var user = _users.Where(x => x.Key == Context.ConnectionId).Select(x => x.Value).FirstOrDefault();
room = _rooms.FirstOrDefault(x => x.Name == room.Name);
var card = room.Cards.FirstOrDefault(x => x.User.Email == user.Email);
if (card == null)
{
card = new PokerCard
{
User = user,
Value = cardValue
};
room.Cards.Add(card);
}
card.Value = cardValue;
// tell the people in this room that your card has changed
Clients.Group(room.Name).cardChanged(card);
}
/// <summary>
/// 发出接受到的所有牌
/// </summary>
public void FastDeal()
{
if (_dealingCards.Count <= 0)
{
return;
}
IsBigDeal = false;
int cardCount = _dealingCards.Count;
for (int i = 0; i < cardCount; i++)
{
PokerInfo pokerInfo = _dealingCards.Dequeue();
var panel = App.GameData.GetPlayer <DuifenPlayerPanel>(pokerInfo.Seat, true);
if (panel.HaveThisCard(pokerInfo.CardIndex))
{
panel.TurnCard(pokerInfo.CardIndex, pokerInfo.PokerVal, false);
}
else
{
PokerCard poker = DealOnes(panel.PokersTrans[pokerInfo.CardIndex], pokerInfo.PokerVal, pokerInfo.CardIndex);
panel.AddPoker(poker);
}
panel.ShowBetLabel();
}
}
public static void DealCard(int userCount, out List <List <PokerCard> > allUserCards, out List <PokerCard> bottomCards)
{
allUserCards = new List <List <PokerCard> >();
bottomCards = new List <PokerCard>();
Random ra = new Random();
List <PokerCard> tempCards = new List <PokerCard>(CardsCount);
for (int userIndex = 0; userIndex < userCount; ++userIndex)
{
List <PokerCard> oneUserCards = new List <PokerCard>();
for (int icard = 0; icard < UserCardsCount; ++icard)
{
int randIndex = ra.Next(0, _cards.Count - 1);
PokerCard card = _cards[randIndex];
oneUserCards.Add(card);
tempCards.Add(card);
_cards.RemoveAt(randIndex);
}
allUserCards.Add(oneUserCards);
}
int leftCount = _cards.Count;
for (int i = 0; i < leftCount; ++i)
{
int randIndex = ra.Next(0, _cards.Count - 1);
PokerCard card = _cards[randIndex];
bottomCards.Add(card);
tempCards.Add(card);
_cards.RemoveAt(randIndex);
}
_cards = tempCards;
}
/// <summary>
/// 发一张牌 有过程
/// </summary>
protected override GameObject DealOnes(Transform from, Transform to, int cardValue = 0, bool isBig = false, int index = 0)
{
GameObject gob = Instantiate(PokerPrefab);
var gobTran = gob.transform;
gobTran.parent = from;
gobTran.localPosition = Vector3.zero;
gobTran.parent = to;
gobTran.localScale = isBig ? Vector3.one * SelfCardScale : Vector3.one;
var betPoker = gobTran.GetComponentInParent <BetPoker>();
betPoker.MoveCards(index);
PokerCard pCard = gob.GetComponent <PokerCard>();
pCard.SetCardDepth(100 + index * 2);
pCard.SetCardId(cardValue);
var comp = gob.GetComponent <TweenPosition>();
comp.duration = 0.15f;//0.25f;
comp.from = gob.transform.localPosition;
comp.to = Vector3.zero;
comp.ResetToBeginning();
comp.PlayForward();
comp.onFinished.Add(new EventDelegate
(() =>
{
pCard.TurnCard();
}));
return(gob);
}
public void CheckIsStraight()
{
PokerCard[] CommCards = new PokerCard[5];
CommCards[0] = new PokerCard(PokerCard.Cards.Four, PokerCard.Suits.Clubs);
CommCards[1] = new PokerCard(PokerCard.Cards.Six, PokerCard.Suits.Spades);
CommCards[2] = new PokerCard(PokerCard.Cards.Eight, PokerCard.Suits.Hearts);
CommCards[3] = new PokerCard(PokerCard.Cards.Eight, PokerCard.Suits.Spades);
CommCards[4] = new PokerCard(PokerCard.Cards.King, PokerCard.Suits.Spades);
PokerCard[] HoleCardsCheck = new PokerCard[2];
HoleCardsCheck[0] = new PokerCard(PokerCard.Cards.Five, PokerCard.Suits.Hearts);
HoleCardsCheck[1] = new PokerCard(PokerCard.Cards.Seven, PokerCard.Suits.Diamonds);
PokerHand HandCheck = new PokerHand(HoleCardsCheck, CommCards);
Assert.IsTrue(PokerRules.PokerRules.IsStraight(HandCheck, CommCards).Card == PokerCard.Cards.Eight);
//With low Ace
CommCards[0] = new PokerCard(PokerCard.Cards.Four, PokerCard.Suits.Clubs);
CommCards[1] = new PokerCard(PokerCard.Cards.Two, PokerCard.Suits.Spades);
CommCards[2] = new PokerCard(PokerCard.Cards.King, PokerCard.Suits.Hearts);
CommCards[3] = new PokerCard(PokerCard.Cards.Queeen, PokerCard.Suits.Spades);
CommCards[4] = new PokerCard(PokerCard.Cards.Ace, PokerCard.Suits.Spades);
HoleCardsCheck[0] = new PokerCard(PokerCard.Cards.Five, PokerCard.Suits.Hearts);
HoleCardsCheck[1] = new PokerCard(PokerCard.Cards.Three, PokerCard.Suits.Diamonds);
HandCheck = new PokerHand(HoleCardsCheck, CommCards);
Assert.IsTrue(PokerRules.PokerRules.IsStraight(HandCheck, CommCards).Card == PokerCard.Cards.Five);
}
public ICollection <PokerCard> VotePokerCard(string backlogItemUId, PokerCard card)
{
card.MemberUId = authorizationService.SignedMemberProfile.MemberUId;
card.BacklogItemUId = backlogItemUId;
backlogRepository.SavePokerCard(card);
return(backlogRepository.GetPokerCards(card.BacklogItemUId));
}
public void SavePokerCard(PokerCard card)
{
using (var context = new ScrumFactoryEntities(this.connectionString))
{
PokerCard oldCard = context.PokerCards.Where(c => c.MemberUId == card.MemberUId && c.BacklogItemUId == card.BacklogItemUId).SingleOrDefault();
if (oldCard == null)
{
card.VoteDate = System.DateTime.Now;
context.PokerCards.AddObject(card);
}
else
{
if (!card.Value.HasValue)
{
context.PokerCards.DeleteObject(oldCard);
var now = System.DateTime.Now.AddHours(-2);
var strNow = now.Year + "-" + now.Month + "-" + now.Day + " " + now.Hour + ":" + now.Minute + ":" + now.Second;
context.ExecuteStoreCommand("DELETE FROM factory.PokerCard WHERE VoteDate < '" + strNow + "'");
}
else
{
card.VoteDate = System.DateTime.Now;
context.ApplyCurrentValues <PokerCard>("PokerCard", card);
}
}
context.SaveChanges();
}
}
public override void startTableOk(int[] cardHand, Message msg, string[] nickPlay)
{
base.startTableOk(cardHand, msg, nickPlay);
tongMoney = 0;
players[0].setCardHand(new int[] { cardHand[0], cardHand[1] }, true, false, false);
if (players[0].isPlaying())
{
players[0].setLoaiBai(PokerCard.getTypeOfCardsPoker(players[0].cardHand.getArrCardAll()));
}
players[0].cardHand.getCardbyPos(0).setMo(true);
players[0].cardHand.getCardbyPos(1).setMo(true);
for (int i = 0; i < players.Length; i++)
{
if (players[i].isPlaying())
{
players[i].setMoneyChip(BaseInfo.gI().betMoney);
if (i != 0)
{
players[i].setCardHand(new int[] { 52, 52 }, true, false, false);
}
players[i].chipBay.onMoveto(players[i].getMoneyChip(), 1);
tongMoney += players[i].getMoneyChip();
}
}
chip_tong.setMoneyChipChu(tongMoney);
}
private PokerCard randomPokerCard()
{
Sprite randSprite = CardFace[UnityEngine.Random.Range(0, 52)];
PokerCard card = new PokerCard(randSprite, CardBack);
return(card);
}
public PokerCard DrawACard()
{
int number = Rnd.Next(0, PokerCards.Count - 1);
PokerCard pokerCard = PokerCards[number];
PokerCards.RemoveAt(number);
return(pokerCard);
}
public DealThirdCardEvent(List <long> coinPool, PokerCard card, List <int> order, int cardType, int point)
{
CoinPool = coinPool;
Card = card;
Order = order;
CardType = cardType;
Point = point;
}
public void TestConstructor()
{
// Make sure we get back thesame suit/face that we put in
// Assume that if we can put in one combo then it will work for others.
ICard c = new PokerCard(CardSuit.Club, CardFace.AceHigh);
Assert.AreEqual(CardSuit.Club, c.Suit);
Assert.AreEqual(CardFace.AceHigh, c.Face);
}
private void LicensingToOneSide(PokerSide oneSide, int num)
{
for (int i = 0; i < num; i++)
{
PokerCard card = CardLibrary.FirstOrDefault();
oneSide.Cards.Add(card);
CardLibrary.Remove(card);
}
}
public static int BombCompare(ref List <PokerCard> sourceCards, ref List <PokerCard> targetCards)
{
PokerCard source4Card = null;
PokerCard source1Card = null;
foreach (var g in sourceCards.GroupBy(c => c.ToString()))
{
if (g.Count() == 4)
{
source4Card = g.FirstOrDefault();
}
else
{
source1Card = g.FirstOrDefault();
}
}
PokerCard target4Card = null;
PokerCard target1Card = null;
foreach (var g in targetCards.GroupBy(c => c.ToString()))
{
if (g.Count() == 4)
{
target4Card = g.FirstOrDefault();
}
else
{
target1Card = g.FirstOrDefault();
}
}
if (source4Card.Num > target4Card.Num)
{
return(1);
}
else if (source4Card.Num < target4Card.Num)
{
return(-1);
}
else
{
if (source1Card.Num > target1Card.Num)
{
return(1);
}
else if (source1Card.Num < target1Card.Num)
{
return(-1);
}
else
{
return(0);
}
}
}
public bool HasAValidMove(Hand hand, PokerCard topOfDeck)
{
for (int i = 0; i < 5; i++)
{
if ((SameSuitCheck(hand, i, topOfDeck) || SameValueCheck(hand, i, topOfDeck) || Crazy8Check(hand, i)) && !IsDiscarded(hand, i))
{
return(true);
}
}
return(false);
}
public bool SameSuitCheck(Hand hand, int index, PokerCard topOfDeck)
{
if (hand.GetaCard(index).GetSuit() == topOfDeck.GetSuit())
{
return(true);
}
else
{
return(false);
}
}
public void TestEquals()
{
// Ensure that we can evaluate if two poker cards are equal by value or not.
ICard c1 = new PokerCard(CardSuit.Club, CardFace.AceHigh);
ICard c2 = new PokerCard(CardSuit.Club, CardFace.AceHigh);
ICard c3 = new PokerCard(CardSuit.Heart, CardFace.Nine);
Assert.AreEqual(c1, c2);
Assert.AreNotEqual(c1, c3);
Assert.AreNotEqual(c2, c3);
}
public PokerCard PlayCard(Hand hand, int index, PokerCard topOfDeck)
{
if (CheckIfValidMove(hand, index, topOfDeck))
{
PokerCard newTopHand = hand.GetaCard(index);
newTopHand.isDiscarded = true;
hand.setACard(index, newTopHand);
return(newTopHand);
}
return(hand.GetaCard(index));
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
var cards = PokerCard.CreateCardSet(true);
foreach (var item in cards)
{
Console.Write($"{item.Name,-8}");
}
Console.ReadKey();
}
} //edited for m3
public void playerDrawCard()
{
PokerCard drawnCard = playingDeck.DrawPokerCardTop();
drawnCard.makeCard(blankCard);
playerCards.AddFirst(drawnCard);
Instantiate(drawnCard.Face, playerCardPosition[playerCardPointer++].transform);
updatePlayerPoints();
if (playerPoints > 21)
{
playerBusted();
}
} //edited for m3
public void checkLung(int[] cardChi1, int[] cardChi2, int[] cardChi3)
{
if (PokerCard.isBiggerArray(cardChi2, cardChi1) ||
PokerCard.isBiggerArray(cardChi3, cardChi2) ||
PokerCard.isBiggerArray(cardChi3, cardChi1))
{
setLung(true);
}
else
{
setLung(false);
}
}
internal void OnInfo(Message msg)
{
try {
string nicksb = msg.reader().ReadUTF();
string nickbb = msg.reader().ReadUTF();
long moneyInPot = msg.reader().ReadLong();
if (((LiengPlayer)playerMe).IsPlaying)
{
//players[0].setLoaiBai(PokerCard.getTypeOfCardsPoker(PokerCard.add2ArrayCard(
// players[0].cardHand.getArrCardAll(), cardTable.getArrCardAll())));
int type = PokerCard.getTypeOfCardsPoker(PokerCard.add2ArrayCard(list_my_card.ToArray(), cardTableManager.list_card.ToArray()));
((LiengPlayer)playerMe).SetTypeCard(type);
}
Debug.LogError("nicksb " + nicksb
+ "\nnickbb " + nickbb
+ "\nmoneyInPot " + moneyInPot);
LiengPlayer plbb = (LiengPlayer)GetPlayerWithName(nickbb);
LiengPlayer plsb = (LiengPlayer)GetPlayerWithName(nicksb);
if (plbb != null)
{
plbb.MoneyChip = moneyInPot * 2 / 3;
plbb.MoveChip(moneyInPot * 2 / 3, SumChipControl.transform.position);
}
if (plsb != null)
{
plsb.MoneyChip = moneyInPot / 3;
plsb.MoveChip(moneyInPot / 3, SumChipControl.transform.position);
}
tongMoney = 0;
for (int i = 0; i < ListPlayer.Count; i++)
{
if (ListPlayer[i].IsPlaying)
{
tongMoney += ((LiengPlayer)ListPlayer[i]).MoneyChip;
}
}
//for (int i = 0; i < nUsers; i++) {
// if (players[i].isPlaying()) {
// tongMoney = tongMoney + players[i].getMoneyChip();
// }
//}
//chip_tong.setMoneyChip(tongMoney);
//chip_tong.setVisible(true);
SumChipControl.MoneyChip = tongMoney;
} catch (Exception ex) {
Debug.LogException(ex);
}
}
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 PokerDeck()
{
Cards = new PokerCard[52];
int index = 0;
for (int i = 1; i < 14; i++)
{
Cards[index] = new PokerCard(Suit.Spades, i);
Cards[++index] = new PokerCard(Suit.Hearts, i);
Cards[++index] = new PokerCard(Suit.Diamonds, i);
Cards[++index] = new PokerCard(Suit.Clubs, i);
index++;
}
}
public static string ConvertPokerCardToString(PokerCard card) {
string suit = "";
string rank = "";
switch (card.GetSuit()) {
case Puppet.ECardSuit.Bitch :
suit = "c";
break;
case Puppet.ECardSuit.Diamond :
suit = "d";
break;
case Puppet.ECardSuit.Heart :
suit = "h";
break;
case Puppet.ECardSuit.Spade :
suit = "s";
break;
}
switch (card.GetRank()) {
case Puppet.ECardRank.King:
rank = "K";
break;
case Puppet.ECardRank.Queen:
rank = "Q";
break;
case Puppet.ECardRank.Ace:
rank = "A";
break;
case Puppet.ECardRank.Jack:
rank = "J";
break;
default :
rank = ((int)card.GetRank()).ToString();
break;
}
return rank + suit;
}
public bool Equals(PokerCard card)
{
if (card == null)
return false;
return (card.CardFace.Equals(CardFace) && card.CardSuit.Equals(CardSuit));
}
public void It_should_rank_8ofspades_less_than_9ofhearts()
{
var nine = new PokerCard("9H");
var eight = new PokerCard("8S");
Assert.Less(eight, nine);
}
public void It_should_rank_9ofhearts_higher_than_8ofspades()
{
var heartAce = new PokerCard("9H");
var spadesKing = new PokerCard("8S");
Assert.Greater(heartAce, spadesKing);
}
public void It_should_rank_King_as_higher_than_queen()
{
var king = new PokerCard("KS");
var queen = new PokerCard("QS");
Assert.Greater(king, queen);
}
public void SetDataCard(PokerCard card)
{
this.SetHighlight(false);
this.card = card;
UpdateUI();
}
public void SetDataCard(PokerCard card, int index)
{
SetDataCard(card);
this.index = index;
}
private void SendVote(PokerCard pokerCard)
{
PokerVote vote = new PokerVote();
vote.VoteParticipant = ScrumPokerSession.GameParticipant;
vote.VoteCard = pokerCard;
ScrumPokerSession.CurrentGame.SendVote(vote);
pnlVote.Visible = false;
}
