Esempio n. 1
0
 public void OnDeal(ObservableCollection <ServiceCard> cards, ServiceCard trump, int playerId, int GameId)
 {
     if (_gameId == GameId)
     {
         _trump = serviseCardToCard(trump);
         if (playerId == 0)
         {
             foreach (ServiceCard sc in cards)
             {
                 _currentPlayer.Hand.Add(serviseCardToCard(sc));
             }
         }
         else
         {
             foreach (Player p in _otherPlayers)
             {
                 if (p.Id == playerId)
                 {
                     foreach (ServiceCard sc in cards)
                     {
                         p.Hand.Add(serviseCardToCard(sc));
                     }
                 }
             }
         }
     }
 }
        public RecruitCardGroup(ServiceCard serviceCard,
                                FirstCardGroup firstCardGroup,
                                SecondCardGroup secondCardGroup,
                                ThirdCardGroup thirdCardGroup)
        {
            if (serviceCard == null)
            {
                throw new ArgumentNullException(nameof(serviceCard));
            }

            if (firstCardGroup == null)
            {
                throw new ArgumentNullException(nameof(firstCardGroup));
            }

            if (secondCardGroup == null)
            {
                throw new ArgumentNullException(nameof(secondCardGroup));
            }

            if (thirdCardGroup == null)
            {
                throw new ArgumentNullException(nameof(thirdCardGroup));
            }

            ServiceCard     = serviceCard;
            FirstCardGroup  = firstCardGroup;
            SecondCardGroup = secondCardGroup;
            ThirdCardGroup  = thirdCardGroup;
        }
Esempio n. 3
0
        /// <inheritdoc/>
        public void CreateNewMatch(MatchDto gameMatchDto)
        {
            IList <ServiceCard> serviceCards = new List <ServiceCard>();

            foreach (var cardDto in gameMatchDto.CardDeckDto.Cards)
            {
                ServiceCard card = new ServiceCard()
                {
                    CardId     = cardDto.CardId,
                    FrontImage = cardDto.FrontImage
                };
                serviceCards.Add(card);
            }

            ServiceCardDeck serviceCardDeck = new ServiceCardDeck()
            {
                CardDeckId    = gameMatchDto.CardDeckDto.CardDeckId,
                NumberOfPairs = gameMatchDto.CardDeckDto.NumberOfPairs,
                Cards         = serviceCards,
                BackImage     = gameMatchDto.CardDeckDto.BackImage
            };

            ServiceMatch serviceMatch = new ServiceMatch()
            {
                Host = gameMatchDto.Host,
                MaxNumberOfPlayers = gameMatchDto.MaxNumberOfPlayers,
                HasStarted         = false,
                ServiceCardDeck    = serviceCardDeck
            };

            _matches.Add(serviceMatch);
        }
Esempio n. 4
0
        public ServiceCard cardToServiceCard(Card c)
        {
            ServiceCard ret = new ServiceCard();

            ret.Rank = (int)c.Rank;
            ret.Kind = (int)c.Kind;
            return(ret);
        }
Esempio n. 5
0
        public void OnDeal(ServiceCard[] cards, ServiceCard trump, long playerId, int GameId)
        {
            SendOrPostCallback callback = new SendOrPostCallback(
                delegate(object state) {
                OnDeal_UI(cards, trump, playerId, GameId);
            }
                );

            _uiSyncContext.Post(callback, "");
        }
Esempio n. 6
0
        public void OnNotifyMove(ServiceCard movedCard, int gameId, long playerId, long nextHit)
        {
            SendOrPostCallback callback = new SendOrPostCallback(
                delegate(object state)
            {
                OnNotifyMove_UI(movedCard, gameId, playerId, nextHit);
            }
                );

            _uiSyncContext.Post(callback, "");
        }
Esempio n. 7
0
 public void OnHitMade(ServiceCard movedCard, int gameId, int playerId)
 {
     if (_gameId == gameId)
     {
         Card c = serviseCardToCard(movedCard);
         referToView(c);
         MoveNr += 1;
         CardsOnTable.Add(c);
         setPlayerActionColor();
     }
 }
Esempio n. 8
0
 public void OnHitMade_UI(ServiceCard movedCard, int gameId, long playerId)
 {
     Trace.WriteLine("VIEW: OnHitMade called()");
     if (_gameId == gameId)
     {
         Card c = serviseCardToCard(movedCard);
         referToView(c);
         MoveNr += 1;
         CardsOnTable.Add(c);
         setPlayerActionColor();
     }
 }
Esempio n. 9
0
        public RecruitInfoMapper(RecruitCardGroup recruitCardGroup)
        {
            if (recruitCardGroup == null)
            {
                throw new ArgumentNullException(nameof(recruitCardGroup));
            }

            _serviceCard     = recruitCardGroup.ServiceCard;
            _firstCardGroup  = recruitCardGroup.FirstCardGroup;
            _secondCardGroup = recruitCardGroup.SecondCardGroup;
            _thirdCardGroup  = recruitCardGroup.ThirdCardGroup;
        }
        public RecruitCardGroup(string personalPhotoDirectoryPath)
        {
            if (string.IsNullOrWhiteSpace(personalPhotoDirectoryPath))
            {
                throw new ArgumentNullException(nameof(personalPhotoDirectoryPath));
            }

            ServiceCard     = new ServiceCard();
            FirstCardGroup  = new FirstCardGroup(personalPhotoDirectoryPath);
            SecondCardGroup = new SecondCardGroup();
            ThirdCardGroup  = new ThirdCardGroup();
        }
Esempio n. 11
0
 public void OnNotifyMove_UI(ServiceCard movedCard, int gameId, long playerId, long nextHit)
 {
     if (_gameId == gameId)
     {
         Card c = serviseCardToCard(movedCard);
         referToView(c);
         MoveNr += 1;
         CardsOnTable.Add(c);
         HitIndex = nextHit;
         setPlayerActionColor();
     }
 }
Esempio n. 12
0
        public void OnDeal_UI(ServiceCard[] cards, ServiceCard trump, long playerId, int GameId)
        {
            Trace.WriteLine("VIEW: OnDeal called()");

            if (_gameId == GameId)
            {
                _trump = serviseCardToCard(trump);
                if (playerId == _currentPlayer.Id)
                {
                    foreach (ServiceCard sc in cards)
                    {
                        _currentPlayer.Hand.Add(serviseCardToCard(sc));
                    }
                    DealEvent += 1;
                }
            }
        }
        public void notifyHitMade(int gameId, ServiceCard movedCard)
        {
            Trace.WriteLine("SERVICE: notify hit made");
           
            Game g = listOfGames.ElementAt(gameId - 1);
            g.Players[g.HitsIndex].CardsInHand -= 1;
            g.NrOfCardsOnTable += 1;
             Trace.WriteLine("SERVICE: cards on table "+g.NrOfCardsOnTable);
            if (g.Players[g.HitsIndex].CardsInHand == 0 && g.TopCardIndex <= 0)
            {
                g.Players[g.HitsIndex].Finished = true;
                if (isGameOver(gameId))
                {
                    for (int i = 0; i < g.Count; i++)
                    {
                        int looser = getNextActivePlayerIndex(g, g.HitsIndex);

                        Subscriber s = getSubscriberById(g.Players[i].Id);
                        IServiceCallback cb = s.callback;
                        cb.OnGameOver(gameId, g.Players[looser].Id);
                    }

                    return;
                }
                else {
                    for (int i = 0; i < g.Count; i++)
                    {
                        Subscriber s = getSubscriberById(g.Players[i].Id);
                        IServiceCallback cb = s.callback;
                        cb.OnPlayerFinished(gameId, g.Players[g.HitsIndex].Id);
                    }
                }
                   
            }
            if (g.NrOfCardsOnTable == 12)
            {
                setNextMoveAndHitId(gameId);
                for (int i = 0; i < g.Count; i++)
                {
                    Subscriber s = getSubscriberById(g.Players[i].Id);
                    IServiceCallback cb = s.callback;
                    Trace.WriteLine("SERVICE: calling round over");
                    Trace.WriteLine("SERVICE: hit index" +g.HitsIndex+" moveIndex "+g.MovesIndex);
                    cb.OnHitMade(movedCard, gameId, g.Players[g.HitsIndex].Id);
                    cb.OnRoundOver(gameId, g.Players[g.MovesIndex].Id, g.Players[g.HitsIndex].Id);
                }
                
            }
            else
            {
                for (int i = 0; i < g.Count; i++)
                {
                    Subscriber s = getSubscriberById(g.Players[i].Id);
                    IServiceCallback cb = s.callback;
                    cb.OnHitMade(movedCard, gameId, g.Players[g.HitsIndex].Id);
                }
            }
        }
        /// <summary>
        /// Sends card to the game. Severely unreasonable approach
        /// </summary>
        /// <param name="cardMoved">card moved</param>
        /// <param name="playerId">playet that made the move</param>
        /// <param name="gameId">game in view</param>
        public void notifyMove(ServiceCard cardMoved, long playerId, int gameId)
        {
            Game g = listOfGames.ElementAt(gameId - 1);
            ServiceUser player = getUserById(gameId, playerId);
            player.CardsInHand -= 1;
            g.NrOfCardsOnTable += 1;
            
            if (player.CardsInHand == 0 && g.TopCardIndex <= 0)
            {
                player.Finished = true;

                if (isGameOver(gameId))
                {
                    for (int i = 0; i < g.Count; i++)
                    {
                        ServiceUser p = g.Players[i];
                        Subscriber s = getSubscriberById(p.Id);
                        IServiceCallback cb = s.callback;

                        cb.OnGameOver(gameId, g.Players[g.HitsIndex].Id);
                        Trace.WriteLine("SERVICE: Calling back to notify Game Over!");
                    }

                    return;
                }
                else
                {
                    for (int i = 0; i < g.Count; i++)
                    {
                        ServiceUser p = g.Players[i];
                        Subscriber s = getSubscriberById(p.Id);
                        IServiceCallback cb = s.callback;

                        cb.OnPlayerFinished(gameId, playerId);
                        Trace.WriteLine("SERVICE: Calling back to notify player finished!");
                    }
                }
                    
            }
            for (int i = 0; i < g.Count; i++)
            {
                ServiceUser p = g.Players[i];
                Subscriber s = getSubscriberById(p.Id);
                IServiceCallback cb = s.callback;

                cb.OnNotifyMove(cardMoved, gameId, playerId, g.Players[g.HitsIndex].Id);//seepärast peakski teenusele lisaks olema back endis veel üks klass
                Trace.WriteLine("SERVICE: Calling back to notify move done!");
            }
            
            
        }
        public void dealCards(int gameid)
        {
            Subscriber me = GetMe();
            Trace.WriteLine("SERVICE: Dealing card !!!");
            Game g = listOfGames.ElementAt(gameid - 1);
            int deckIndex = g.Deck.Length - 1;

            for (int i = 0; i < g.Count; i++)
            {
                ServiceCard[] cards = new ServiceCard[6];
                for (int j = 0; j < 6; j++)
                {
                    cards[j] = g.Deck[deckIndex];
                    deckIndex = deckIndex - 1;
                }
                ServiceUser p = g.Players[i];
                p.CardsInHand = 6;
                Subscriber s = getSubscriberById(p.Id);
                IServiceCallback cb = s.callback;
                Trace.WriteLine("SERVICE: Calling callback " );
                Trace.WriteLine("SERVICE: Calling player " +s.nickname);
                Trace.WriteLine("SERVICE: Subscribers " + subscrbers.Count);
                cb.OnDeal(cards, g.Deck[0], g.Players[i].Id, g.Id);
                Trace.WriteLine("SERVICE: Calling back done!");
            }
            g.TopCardIndex = deckIndex;
            Trace.WriteLine("SERVICE: deal done!");
        }
 public void initGameDeck(int gameid)
 {
     Game g = listOfGames.ElementAt(gameid - 1);
     g.Deck = new ServiceCard[36];
     int cnt = 0;
     for (int s = 1; s < 5; s++)
     {
         for (int i = 6; i < 15; i++)
         {
             ServiceCard c = new ServiceCard();
             c.Kind = s;
             c.Rank = i;
             g.Deck[cnt] = c;
             cnt += 1;
         }
     }
     g.TopCardIndex = g.Deck.Length - 1;
     g.State = 1; //game has started
 }
Esempio n. 17
0
        public Card serviseCardToCard(ServiceCard arg)
        {
            Card card = new Card(arg.Kind, arg.Rank);

            return(card);
        }