Esempio n. 1
0
            public ItemsCreatedEvent(List <GridNodeState> createdItems)
            {
                CreatedItems = new List <GridEventItem>(createdItems.Count);

                foreach (var item in createdItems)
                {
                    CreatedItems.Add(GridEventItem.Create(item));
                }
            }
Esempio n. 2
0
            public ItemsMatchedEvent(List <Tuple <int, GridNodeState> > matchedItems)
            {
                MatchedItems = new List <GridEventItem>(matchedItems.Count);

                // calculate total points for this event
                foreach (var(points, nodeState) in matchedItems)
                {
                    MatchedItems.Add(GridEventItem.Create(nodeState, points));
                    EventPoints += points;
                }
            }
Esempio n. 3
0
        private bool CollapseGridItems(ref List <Level.Event> gridUpdateEvents)
        {
            var movedItems = new List <GridEventItem>();

            for (int x = 0; x < Width; x++)
            {
                for (int y = 1; y < Height; y++)                        // skip the lowest row
                {
                    // find a filled node
                    var node = Grid[x, y];
                    if (!node.IsFilled())
                    {
                        continue;
                    }

                    // collapse left
                    var nodeLeft = TryGetGridNodeState(x - 1, y - 1);
                    if (nodeLeft?.IsEmpty() == true)
                    {
                        nodeLeft.SetItemId(node.ItemId);
                        node.RemoveItem();

                        // record the event
                        var movedItem = GridEventItem.Create(nodeLeft, 0, node.Index);
                        movedItems.Add(movedItem);
                        continue;
                    }

                    // collapse right
                    var nodeRight = TryGetGridNodeState(x + 1, y - 1);
                    if (nodeRight?.IsEmpty() == true)
                    {
                        nodeRight.SetItemId(node.ItemId);
                        node.RemoveItem();

                        // record the event
                        var movedItem = GridEventItem.Create(nodeRight, 0, node.Index);
                        movedItems.Add(movedItem);
                        continue;
                    }
                }
            }

            if (movedItems.Count > 0)
            {
                var itemsMovedEvent = new Level.ItemsMovedEvent(movedItems);
                gridUpdateEvents.Add(itemsMovedEvent);
                return(true);
            }

            return(false);
        }
Esempio n. 4
0
        public Level.ItemsSwappedEvent ShuffleGridItems()
        {
            var filledNodes = new List <GridNodeState>();

            for (int x = 0; x < Width; x++)
            {
                for (int y = 0; y < Height; y++)
                {
                    var node = Grid[x, y];
                    if (node.IsFilled())
                    {
                        filledNodes.Add(node);
                    }
                }
            }

            var swappedItems = new List <GridEventItem>();

            int count = filledNodes.Count;

            for (int i = 0; i < count; i++)
            {
                var node1 = filledNodes[i];

                int randomIndex;
                do
                {
                    randomIndex = Random.Range(0, count);
                } while (randomIndex == i);
                var node2 = filledNodes[randomIndex];

                // swap
                var temp = node2.ItemId;
                node2.SetItemId(node1.ItemId);
                node1.SetItemId(temp);

                // record the event
                var swappedItem = GridEventItem.Create(node1, 0, node2.Index);
                swappedItems.Add(swappedItem);
            }

            return(new Level.ItemsSwappedEvent(swappedItems));
        }
Esempio n. 5
0
        private bool PullDownGridItems(ref List <Level.Event> gridUpdateEvents)
        {
            var movedItems = new List <GridEventItem>();

            for (int x = 0; x < Width; x++)
            {
                for (int y = 0; y < Height; y++)
                {
                    // find an empty node
                    var node = Grid[x, y];
                    if (!node.IsEmpty())
                    {
                        continue;
                    }

                    // find an item above
                    var aboveFilledNode = FindFirstFilledNodeAbove(x, y);
                    if (aboveFilledNode != null)
                    {
                        // pull the item down
                        node.SetItemId(aboveFilledNode.ItemId);
                        aboveFilledNode.RemoveItem();

                        // record the event
                        var movedItem = GridEventItem.Create(node, 0, aboveFilledNode.Index);
                        movedItems.Add(movedItem);
                    }
                }
            }

            if (movedItems.Count > 0)
            {
                var itemsMovedEvent = new Level.ItemsMovedEvent(movedItems);
                gridUpdateEvents.Add(itemsMovedEvent);
                return(true);
            }

            return(false);
        }
Esempio n. 6
0
 public ItemsDestroyedEvent(CauseOfDeath reason, List <GridNodeState> destroyedItems)
 {
     Reason         = reason;
     DestroyedItems = new List <GridEventItem>(destroyedItems.Select(item => GridEventItem.Create(item, 0)));
 }