Esempio n. 1
0
        /// <summary>
        /// Анимация счета за уничтожение цепочки
        /// </summary>
        /// <param name="chain">Уничтожаемая цепочка.</param>
        private void AnimateScore(GemList chain)
        {
            SKSpriteNode firstGem = chain.GetFirstGem().Sprite;
            SKSpriteNode lastGem  = chain.GetLastGem().Sprite;

            CGPoint centerPoint = new CGPoint(
                (firstGem.Position.X + lastGem.Position.X) / 2,
                (firstGem.Position.Y + lastGem.Position.Y) / 2 - 8);

            SKLabelNode scoreLabel = new SKLabelNode("GillSans-BoldItalic")
            {
                FontSize  = 16,
                Text      = chain.GetScore() + "",
                Position  = centerPoint,
                ZPosition = 300
            };

            gemLayer.AddChild(scoreLabel);

            SKAction moveAction = SKAction.MoveBy(0, 3, 0.7);

            //.Move(by: CGVector(dx: 0, dy: 3), duration: 0.7)
            moveAction.TimingMode = SKActionTimingMode.EaseOut;
            scoreLabel.RunAction(SKAction.Sequence(moveAction, SKAction.RemoveFromParent()));
        }
Esempio n. 2
0
        /// <summary>
        /// Уничтожение цепей в массиве камешков:
        /// метод сканирует массив на цепочки до тех пор, пока они есть,
        /// найдя цепочку заносит ее в список удаляемых цепочек, после чего
        /// уничтожает соответствующие камешки в массиве. Так же проверяет цепочки
        /// в них бонусов, заполняет список с бонусами.
        /// </summary>
        /// <returns><c>true</c> если нашелся хотя бы один активируемый бонус</returns>
        public void DestroyChains()
        {
            GemList chain = RetriveChain();

            // Повторяем процесс пока находим цепочку на уровне
            while (chain != null)
            {
                GemList bonuses;
                bool    needToReiterrate = true;

                while (needToReiterrate)
                {
                    needToReiterrate = false;

                    bonuses = chain.GetAllBonuses();

                    foreach (Gem bonus in bonuses)
                    {
                        // Запоминаем разрушитель в списке разрушителей на анимацию
                        if (!BonusesToAnimate.Contains(bonus))
                        {
                            BonusesToAnimate.Add(bonus);
                        }

                        // Заносим в цепочку весь ряд илил столбец,
                        // в зависимости от напрваленности разрушителя
                        if (bonus.IsALineDestroyer)
                        {
                            if (bonus.IsHorizontal)
                            {
                                for (int column = 0; column < ColumnsNumber; column++)
                                {
                                    if (GemArray[bonus.Row, column] != null && !chain.Contains(GemArray[bonus.Row, column]))
                                    {
                                        chain.Add(GemArray[bonus.Row, column]);
                                    }
                                }
                            }
                            else
                            {
                                for (int row = 0; row < RowsNumber; row++)
                                {
                                    if (GemArray[row, bonus.Column] != null && !chain.Contains(GemArray[row, bonus.Column]))
                                    {
                                        chain.Add(GemArray[row, bonus.Column]);
                                    }
                                }
                            }
                        }

                        if (bonus.IsABomb)
                        {
                            int i;
                            int j;
                            if (bonus.Row == 0)
                            {
                                i = 0;
                            }
                            else
                            {
                                if (bonus.Row - Properties.BombBlastRadius < 0)
                                {
                                    i = 0;
                                }
                                else
                                {
                                    i = bonus.Row - Properties.BombBlastRadius;
                                }
                            }
                            if (bonus.Column == 0)
                            {
                                j = 0;
                            }
                            else
                            {
                                if (bonus.Column - Properties.BombBlastRadius < 0)
                                {
                                    j = 0;
                                }
                                else
                                {
                                    j = bonus.Column - Properties.BombBlastRadius;
                                }
                            }

                            for (int row = i; row <= bonus.Row + Properties.BombBlastRadius && row <= RowsNumber - 1; row++)
                            {
                                for (int column = j; column <= bonus.Column + Properties.BombBlastRadius && column <= ColumnsNumber - 1; column++)
                                {
                                    if (GemArray[row, column] != null && !chain.Contains(GemArray[row, column]))
                                    {
                                        chain.Add(GemArray[row, column]);
                                    }
                                }
                            }
                        }
                    }

                    needToReiterrate = bonuses.Count < chain.GetAllBonuses().Count;
                }

                // подсчитываем очки за цепочку, добавляем их к общему счету
                // int chainScore = (chain.Count - 2) * 10;
                Score += chain.GetScore();

                // заносим цепочку в список на анимацию
                DestroyedChains.Add(chain);

                // удаляем из массива камешки в соответствии с цепью
                chain.ForEach(gem => GemArray[gem.Row, gem.Column] = null);

                // Получаем новую цепочку
                chain = RetriveChain();
            }

            //______ДЛЯ ДЕБАГА______
            PrintOutGemArrayToConsole(false);
        }