Esempio n. 1
0
        public void Initialize(CardBatch hand)
        {
            _hand     = hand;
            _fullDeck = new CardBatch();
            var typeAmt = Enum.GetValues(typeof(CardType)).Length;
            var noAmt   = Enum.GetValues(typeof(CardNo)).Length;

            for (CardType t = CardType.None + 1; (int)t < typeAmt; t++)
            {
                for (CardNo no = CardNo.None + 1; (int)no < noAmt; no++)
                {
                    _fullDeck.Add(new Card(no, t));
                }
            }
            _testCaseDeck = new CardBatch
            {
                new Card(CardNo.Ace, CardType.Diamonds),
                new Card(CardNo.Four, CardType.Clubs),
                new Card(CardNo.Three, CardType.Diamonds),
                new Card(CardNo.Four, CardType.Diamonds),
                new Card(CardNo.Five, CardType.Diamonds),
                new Card(CardNo.Three, CardType.Spades),
                new Card(CardNo.Four, CardType.Spades),
                new Card(CardNo.Ace, CardType.Spades),
                new Card(CardNo.Ace, CardType.Hearts),
                new Card(CardNo.Four, CardType.Hearts),
                new Card(CardNo.Two, CardType.Spades),
            };
            _lastUsedDeck = _fullDeck;
        }
Esempio n. 2
0
        private static void Host_PostBatch(object sender, Chromium.Remote.Event.CfrV8HandlerExecuteEventArgs e)
        {
            UpdateBatchParam(e);

            Task.Factory.StartNew(() =>
            {
                try
                {
                    int index = -1;
                    CardBatch batchReceived = null;
                    foreach (CardInfo item in CardManager.CardInfos)
                    {
                        if (item.Id == 0 && item.CardType < 3)
                        {
                            index += 1;

                            item.CardTime            = CardManager.BatchParam.CardTime;
                            item.CardDistance        = CardManager.BatchParam.CardDistance;
                            item.ParkingRestrictions = CardManager.BatchParam.ParkingRestrictions;
                            item.CardPartition       = CardManager.BatchParam.CardPartition;

                            byte[] by = DistanceIssue.Issue(item);
                            bool ret  = SerialPortManager.WriteSerialPortData(SerialPortManager.Device1, by);
                            if (ret)
                            {
                                ReceivedManager.SetReceivedFunction <CardBatch>();
                                if (batchReceived == null)
                                {
                                    batchReceived = ReceivedManager.GetReceivedFun <CardBatch>();
                                }
                                batchReceived.IssueInfo = item;

                                for (int i = 0; i < 250; i++)
                                {
                                    Thread.Sleep(10);
                                    if (batchReceived.IssueInfo == null)
                                    {
                                        if (item.Id > 0)
                                        {
                                            ViewCallFunction.ViewDisplayBatchContent(item, index);
                                        }
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Log4Helper.ErrorInfo(ex.Message, ex);
                    ViewCallFunction.ViewAlert(ex.Message);
                }
                finally
                {
                    int count = CardManager.CardInfos.Where(w => w.Id == 0 && w.CardType < 3).Count();
                    ViewCallFunction.ViewBatchOver(count);
                }
            });
        }
Esempio n. 3
0
 public void Initialize(CardView.Pool cardPool, CardBatch hand)
 {
     _cardPool              = cardPool;
     _hand                  = hand;
     _cardViews             = new Dictionary <Card, CardView>();
     _radialPlacer          = GetComponent <RadialPlacer>();
     _camera                = Camera.main;
     _hand.OnAdd           += OnAdd;
     _hand.OnChange        += OnChange;
     _hand.OnRemove        += OnRemove;
     _radialPlacer.OnAdapt += OnChange;
 }
Esempio n. 4
0
        /// <summary>
        /// Spawns the cards one by one.
        /// </summary>
        private void Draw(CardBatch deck)
        {
            _drawDisposable?.Dispose();
            _lastUsedDeck = deck;
            var cardsToDraw = Mathf.Min(GameRules.CardsToDraw, deck.Count);
            var i           = 0;

            _drawDisposable = Observable.Interval(TimeSpan.FromSeconds(DrawFrequency)).Subscribe(l =>
            {
                i++;
                _hand.Add(deck.RandomElementAndRemove());
                if (i >= cardsToDraw)
                {
                    _drawDisposable.Dispose();
                }
            });
        }
Esempio n. 5
0
    private void Start()
    {
        var cardBatch = new CardBatch
        {
            new Card(CardNo.Ace, CardType.Spades),
            new Card(CardNo.Two, CardType.Spades),
            new Card(CardNo.Three, CardType.Spades),
            new Card(CardNo.Four, CardType.Spades),
            new Card(CardNo.Three, CardType.Diamonds),
            new Card(CardNo.Four, CardType.Diamonds),
            new Card(CardNo.Five, CardType.Diamonds),
            new Card(CardNo.Ace, CardType.Diamonds),
            new Card(CardNo.Ace, CardType.Hearts),
            new Card(CardNo.Four, CardType.Hearts),
            new Card(CardNo.Four, CardType.Clubs)
        };

        var grouping = GroupingAlgorithms.GetSmartGroups(cardBatch);
        var builder  = new StringBuilder();
        var i        = 0;

        foreach (var group in grouping.Groups)
        {
            i++;
            builder.AppendLine("Group " + i + ":");
            foreach (var card in group)
            {
                builder.AppendLine(card.ToString());
            }
            builder.AppendLine();
        }
        builder.AppendLine("Ungrouped Cards:");
        foreach (var card in grouping.Ungrouped)
        {
            builder.AppendLine(card.ToString());
        }
        Debug.Log(builder.ToString());
    }