Esempio n. 1
0
        /// <summary>
        /// Trash the card from the field.
        /// </summary>
        /// <param name="fieldIndex">Field index.</param>
        /// <param name="cardStr">Card string.</param>
        /// <returns>Trashed card instance.</returns>
        public Card Trash(int fieldIndex, string cardStr)
        {
            GameStatus.Status nextStatus = status.Act(GameStatus.Action.Trash);
            if (GameStatus.Status.Error == nextStatus)
            {
                throw GameException.getAlreadyTrashedException();
            }
            if (fieldIndex >= FIELD_NUM || fieldIndex < 0)
            {
                throw GameException.getFieldIndexException();
            }

            CardDeck deck = this.fields[fieldIndex].CardList[this.turn];

            if (this.fields[fieldIndex].IsFixed || deck.Last().Name != cardStr)
            {
                throw GameException.getCardAlreadyFixedException();
            }


            Card card = deck.Move(cardStr, this.talon.Trash);

            this.lastTrashed      = card;
            this.lastTrashedField = this.fields[fieldIndex];

            status.Current = card.HasSpecial ? nextStatus : GameStatus.Status.Trashed;
            return(card);
        }
Esempio n. 2
0
        /// <summary>
        /// Proceed to the next turn.
        /// </summary>
        public void nextTurn()
        {
            foreach (Field field in this.fields)
            {
                field.Eval();
            }

            if (this.Winner >= 0)
            {
                this.status.Current = GameStatus.Status.RoundEnd;
                return;
            }

            GameStatus.Status nextStatus = this.IsFilled ? GameStatus.Status.First : status.Act(GameStatus.Action.Next);
            if (GameStatus.Status.Error == nextStatus)
            {
                throw GameException.getNotTrashedException();
            }
            this.card9 [this.turn] = Constants.CARD9_NONE;
            this.turn             = (this.turn + 1) % 2;
            this.lastTrashedField = null;
            this.lastTrashed      = null;

            int drawNum = 5 - this.Player.Hand.Count();

            for (int i = 0; i < drawNum; i++)
            {
                this.Draw();
            }
            this.status.Current = nextStatus;
        }
Esempio n. 3
0
 /// <summary>
 /// Judge if the card string equals to this card.
 /// </summary>
 /// <param name="cardStr">The card name.</param>
 /// <returns>True: same  False: different.</returns>
 public bool IsMatch(string cardStr)
 {
     if (!regex.IsMatch(cardStr))
     {
         throw GameException.getCardStrException(cardStr);
     }
     return(this.name == cardStr);
 }
Esempio n. 4
0
        /// <summary>
        /// Draw a card from this talon and send it to another deck.
        /// </summary>
        /// <param name="to">The deck to send the card.</param>
        /// <returns>Drawn card.</returns>
        public Card Draw(CardDeck to)
        {
            if (this.list.Count() == 0)
            {
                throw GameException.getNoCardException();
            }
            Card card = this.list.First();

            CardDeck.handler(this, to, card);
            this.Move(card.Name, to);
            return(card);
        }
Esempio n. 5
0
        /// <summary>
        /// Fire the special effect of the card.
        /// </summary>
        /// <param name="opt">Special effect option.</param>
        public void Special(params string[] opt)
        {
            GameStatus.Status nextStatus = status.Act(GameStatus.Action.Special);
            if (GameStatus.Status.Error == nextStatus)
            {
                throw GameException.getAlreadyTrashedException();
            }
            bool ret = this.lastTrashed.Special(this, opt);

            if (ret)
            {
                status.Current = nextStatus;
            }
        }
Esempio n. 6
0
        /// <summary>
        /// The special skill of this card.
        /// </summary>
        /// <param name="game">Game instance.</param>
        /// <param name="opt">Input option parameter.</param>
        /// <returns>Result.</returns>
        public bool Special(CardGame game, params string[] opt)
        {
            bool ret = true;

            if (this.power == 1)
            {
                Field field = game.Fields[Int32.Parse(opt[1])];
                if (field.IsFixed)
                {
                    throw GameException.getCardAlreadyFixedException();
                }
                string cardStr = opt[0];
                game.Trash(field.Number, cardStr);
                //CardDeck fieldDeck = field.CardList[game.Turn];
                //fieldDeck.Move(cardStr, game.Talon.Trash);
                ret = false;
            }
            else if (this.power == 3)
            {
                int count = game.Player.Hand.Count();
                game.Player.Hand.MoveAll(game.Talon.Trash);
                for (int i = 0; i < count; i++)
                {
                    game.Draw();
                }
            }
            else if (this.power == 5)
            {
                Field field = game.LastTrashedField;
                char  c     = ((string)opt[0])[0];
                field.Color = Color.Get(c);
            }
            else if (this.power == 7)
            {
                Field field = game.Fields[Int32.Parse(opt[1])];
                if (field.IsFixed)
                {
                    throw GameException.getCardAlreadyFixedException();
                }
                string   cardStr   = (string)opt[0];
                CardDeck fieldDeck = field.CardList[(game.Turn + 1) % 2];
                fieldDeck.Move(cardStr, game.Talon.Trash);
            }
            else if (this.power == 9)
            {
                game.Card9[(game.Turn + 1) % 2] = Constants.CARD9_AFFECTED;
            }
            return(ret);
        }
Esempio n. 7
0
        /// <summary>
        /// Move all card to the deck.
        /// </summary>
        /// <param name="to">Target deck.</param>
        public void MoveAll(CardDeck to)
        {
            if (to.size >= 0 && to.list.Count() > to.size - this.list.Count)
            {
                throw GameException.getCardTooManyException();
            }
            List <string> list = new List <string>();

            foreach (Card card in this.list)
            {
                list.Add(card.Name);
            }
            foreach (string name in list)
            {
                this.Move(name, to);
            }
        }
Esempio n. 8
0
        /// <summary>
        /// Move the specified card to the another deck.
        /// </summary>
        /// <param name="cardStr">card string.</param>
        /// <param name="to">Target deck.</param>
        /// <returns>Card instance.</returns>
        public Card Move(string cardStr, CardDeck to)
        {
            if (to.size >= 0 && to.list.Count() == to.size)
            {
                throw GameException.getCardTooManyException();
            }

            Card card = this.Get(cardStr);

            if (card == null)
            {
                throw GameException.getNoCardException();
            }

            if (!this.list.Remove(card))
            {
                throw new Exception();
            }
            CardDeck.handler(this, to, card);
            to.list.Add(card);
            return(card);
        }
Esempio n. 9
0
        /// <summary>
        /// Discard the card to the field.
        /// </summary>
        /// <param name="fieldIndex">Field index.</param>
        /// <param name="cardStr">Card string.</param>
        /// <returns>Discarded card instance.</returns>
        public Card Discard(int fieldIndex, string cardStr)
        {
            GameStatus.Status nextStatus = status.Act(GameStatus.Action.Discard);
            if (GameStatus.Status.Error == nextStatus)
            {
                throw GameException.getAlreadyDiscardedException();
            }

            if (fieldIndex >= FIELD_NUM || fieldIndex < 0)
            {
                throw GameException.getFieldIndexException();
            }

            CardDeck hand = this.players[turn].Hand;
            Card     card = hand.Get(cardStr);

            if (card == null)
            {
                throw GameException.getCardNotFoundException(cardStr);
            }
            hand.Move(cardStr, this.fields[fieldIndex].CardList[turn]);

            if (this.players[turn].Hand.Count() == 0 || this.IsFilled)
            {
                status.Current = GameStatus.Status.End;
            }
            else if (this.card9[turn] == Constants.CARD9_AFFECTED)
            {
                status.Current = GameStatus.Status.Trashed;
            }
            else
            {
                status.Current = nextStatus;
            }
            return(card);
        }
Esempio n. 10
0
 public void CmdError(LilyAcolasia.GameRound round, LilyAcolasia.GameException ex)
 {
     IsCmdSuccess = false;
     Debug.Log("Error: " + ErrorMessages[ex.Type]);
     this.master.UpdateStatus();
 }