Example #1
0
        /// <summary>
        /// Collects moons
        /// </summary>
        /// <param name="moonFlower">The moon to collect from</param>
        /// <param name="moon">The moon to collect</param>
        public void CollectMoon(MoonFlower moonFlower, Moon moon)
        {
            //Collect it
            moonFlower.CollectMoon(moon);

            //Cascade the moons
            moonFlower.CascadeMoons();
        }
Example #2
0
 /// <summary>
 /// Sets one of each type of plant
 /// </summary>
 private void SetPlants()
 {
     _plants[0] = new Tree(-1, -1, new Rectangle());
     _plants[1] = new MoonFlower(-1, -1, new Rectangle());
     _plants[2] = new PeaShooter(-1, -1, new Rectangle());
     _plants[3] = new WallNut(-1, -1, new Rectangle());
     _plants[4] = new SnowPea(-1, -1, new Rectangle());
     _plants[5] = new PotatoMine(-1, -1, new Rectangle());
     _plants[6] = new CherryBomb(-1, -1, new Rectangle());
 }
        /// <summary>
        /// Handles the user grabbing a moon
        /// </summary>
        /// <param name="moon"></param>
        /// <param name="moonflower"></param>
        public void GrabMoon(Moon moon, MoonFlower moonflower)
        {
            // If the mouse is down and the mouse location is within the bounds of the passed in moon.
            if (_isMouseDown && moon.Bounds.Contains(_mouseLocation))
            {
                // Sets the moon's isCollected property to true.
                moon.IsCollected = true;

                // Calls the wrapper to collect the specified moon at the specified moonflower.
                _wrapper.CollectMoon(moonflower, moon);
            }
        }
Example #4
0
        /// <summary>
        /// Moves all of the moons
        /// </summary>
        /// <param name="row">Row</param>
        /// <param name="col">Column</param>
        private void MoveMoons(int row, int col)
        {
            //Check if its a moonflower
            if (_vars.board[row, col] is MoonFlower)
            {
                //Create the moonflower
                MoonFlower moonFlower = _vars.board[row, col] as MoonFlower;

                //Loop through all of the moons to draw
                foreach (Moon moon in moonFlower.GetMoonsToDraw())
                {
                    //Move it
                    moon.Move();
                }
            }
        }
        /// <summary>
        /// Handles the drawing of moons on the board
        /// </summary>
        /// <param name="g"></param>
        public void DrawMoons(Graphics g)
        {
            // Loops through the rows from 0 until the constant row value.
            for (int row = 0; row < ROWS; row++)
            {
                // Loops through the cols from 0 until the constant col value.
                for (int col = 0; col < COLS; col++)
                {
                    // If the plant at the specific board location is a moon flower.
                    if (_wrapper.GetBoard()[row, col] is MoonFlower)
                    {
                        // Creates a moonflower to store the specific plant at the board location as a moonflower.
                        MoonFlower moonflower = _wrapper.GetBoard()[row, col] as MoonFlower;

                        // Creates a list of moons which are to be removed.
                        List <Moon> moonsToBeRemoved = new List <Moon>();

                        // Loops through each moons in the wrapper's list of moons to be drawn.
                        foreach (Moon moon in _wrapper.GetMoonsToDraw(moonflower))
                        {
                            // Draws the moon at its bounds.
                            g.DrawImage(Graphic.GetImage(moon), moon.Bounds);

                            // Calls the method to handle the user's grabbing of a moon.
                            GrabMoon(moon, moonflower);

                            // Checks if the moon is expired and ready to be collected.
                            if (moon.IsExpired)
                            {
                                // Adds that specific moon to the list of moons to be removed.
                                moonsToBeRemoved.Add(moon);
                            }
                        }

                        // Adds the amount of moons that need to be removed to the total amount of moons.
                        _wrapper.AddMoons(moonsToBeRemoved.Count);

                        // Loops through each moon in the list of moons to be removed.
                        foreach (Moon moonToBeRemoved in moonsToBeRemoved)
                        {
                            // Removes the specific moon from the specific moonflower from the wrapper's list of moons to be drawn.
                            _wrapper.GetMoonsToDraw(moonflower).Remove(moonToBeRemoved);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Check if the player picked up any moons
        /// </summary>
        private void CheckMoonPickUp()
        {
            //Loop through all of the rows
            for (int rows = 0; rows < ROWS; rows++)
            {
                //Loop through all of  the columns
                for (int cols = 0; cols < COLS; cols++)
                {
                    //Check if the plant is a moonflower
                    if (_wrapper.GetBoard()[rows, cols] is MoonFlower)
                    {
                        //Create the moonflower
                        MoonFlower moonFlower = _wrapper.GetBoard()[rows, cols] as MoonFlower;

                        //Create the moon to remove
                        Moon toRemove = null;

                        //Loop through all of the moons
                        foreach (Moon moon in _wrapper.GetMoons(moonFlower))
                        {
                            //If the mouse is over the moon
                            if (StaticMethods.MouseIntersects(moon.X, moon.Y, moon.Width, moon.Height, _mouseX, _mouseY))
                            {
                                //Collect the moon
                                moon.IsCollected = true;

                                //Update the moon to remove
                                toRemove = moon;

                                //Break out of the loop
                                break;
                            }
                        }

                        //Check if there is a moon to remove
                        if (toRemove != null)
                        {
                            //Collect the moon
                            _wrapper.CollectMoon(moonFlower, toRemove);
                        }
                    }
                }
            }
        }
        /// <summary>
        /// Handles making moons
        /// </summary>
        /// <param name="endDest"></param>
        internal void MakeMoons(Point endDest)
        {
            // Creates a 2D array to store the board.
            Plant[,] board = _sharedVariables.board;

            // Loops from 0 to the length of the board's first dimension.
            for (int x = 0; x < board.GetLength(0); x++)
            {
                // Loops from 0 to the length of the board's second dimension.
                for (int y = 0; y < board.GetLength(1); y++)
                {
                    // If the specific board location is a moon flower.
                    if (board[x, y] is MoonFlower)
                    {
                        // Creates a moon flower to store the board location as a moon flower.
                        MoonFlower moonFlower = board[x, y] as MoonFlower;

                        // Calls said moon flower to make a moon passing in the end destination of the moon.
                        moonFlower.MakeMoon(endDest);
                    }
                }
            }
        }
        /// <summary>
        /// Draw the moons
        /// </summary>
        /// <param name="g">Graphics to draw on</param>
        /// <param name="row">The row of the plant</param>
        /// <param name="col">The column of the plant</param>
        private void DrawGameMoons(Graphics g, int row, int col)
        {
            //If the plant is a moonflower
            if (_wrapper.GetBoard()[row, col] is MoonFlower)
            {
                //Create the moonflower
                MoonFlower moonFlower = _wrapper.GetBoard()[row, col] as MoonFlower;

                //Store all moons that should be removed
                List <Moon> toRemove = new List <Moon>();

                //Loop through all of the moons for the moonflower
                foreach (Moon moon in _wrapper.GetMoonsToDraw(moonFlower))
                {
                    //Draw the moon
                    g.DrawImage(Properties.Resources.moon, moon.Bounds);

                    //Check if the moon is already collected
                    if (moon.IsExpired)
                    {
                        //Add it to the remove list
                        toRemove.Add(moon);
                    }
                }

                //Add the amount of moons that have been collected
                _wrapper.AddMoons(toRemove.Count);

                //Loop through all of the moons that should be removed
                foreach (Moon moon in toRemove)
                {
                    //Remove the moon
                    _wrapper.GetMoonsToDraw(moonFlower).Remove(moon);
                }
            }
        }
Example #9
0
 /// <summary>
 /// Gets the moons to draw
 /// </summary>
 /// <param name="moonFlower">The moonflower in question</param>
 /// <returns>The moons to draw</returns>
 public List <Moon> GetMoonsToDraw(MoonFlower moonFlower)
 {
     return(moonFlower.GetMoonsToDraw());
 }
Example #10
0
 /// <summary>
 /// Gets the moons for a moonflower
 /// </summary>
 /// <param name="moonFlower">The moonflower in question</param>
 /// <returns>The moons on it</returns>
 public List <Moon> GetMoons(MoonFlower moonFlower)
 {
     return(moonFlower.GetMoons());
 }
        /// <summary>
        /// Buy and place a plant
        /// </summary>
        /// <param name="row">The row to place</param>
        /// <param name="col">The column to place</param>
        /// <param name="bounds">The bounds of the tile</param>
        private void BuyAndPlace(int row, int col, Rectangle bounds)
        {
            //Check if the mouse is pressed and a plant is grabbed
            if (!_mouseDown && _plantGrabbed[_plantGrabbedIndex])
            {
                //Get the grabbed plant
                Plant grabbedPlant = _wrapper.GetPlants()[_plantGrabbedIndex];

                //Create a plant
                Plant plant = null;

                //Check if the grabbed plant is a tree
                if (grabbedPlant is Tree)
                {
                    //Create the new plant
                    plant = new Tree(row, col, bounds);
                }
                ////Check if the grabbed plant is a moonflower
                else if (grabbedPlant is MoonFlower)
                {
                    //Create the new plant
                    plant = new MoonFlower(row, col, bounds);
                }
                //Check if the grabbed plant is a cherrybomb
                else if (grabbedPlant is CherryBomb)
                {
                    //Create the new plant
                    plant = new CherryBomb(row, col, bounds);
                }
                //Check if the grabbed plant is a potatomine
                else if (grabbedPlant is PotatoMine)
                {
                    //Create the new plant
                    plant = new PotatoMine(row, col, bounds);
                }
                //Check if the grabbed plant is a peashooter
                else if (grabbedPlant is PeaShooter)
                {
                    //Create the new plant
                    plant = new PeaShooter(row, col, bounds);
                }
                //Check if the grabbed plant is a snowpea
                else if (grabbedPlant is SnowPea)
                {
                    //Create the new plant
                    plant = new SnowPea(row, col, bounds);
                }
                //Check if the grabbed plant is a wallnut
                else if (grabbedPlant is WallNut)
                {
                    //Create the new plant
                    plant = new WallNut(row, col, bounds);
                }

                //Store the reason that a player can either place or not place a plant
                ModelWrapper.Reason reason = _wrapper.GetReason(row, col, plant);

                //Check if the tile is occupied by a plant
                if (reason == ModelWrapper.Reason.Occupied)
                {
                    //Set the note accordingly
                    _note = OCCUPIED;
                }
                //Check if there is no trees in bounds
                else if (reason == ModelWrapper.Reason.NoTreesNearby)
                {
                    //Set the note accordingly
                    _note = NO_TREES_NEARBY;
                }
                //Check if the player doesnt have enough moons
                else if (reason == ModelWrapper.Reason.InsufficientMoons)
                {
                    //Set the note accordingly
                    _note = INSUFFICIENT_MOONS;
                }

                //Buy and place the plant
                _wrapper.BuyAndPlace(row, col, plant);

                //Release the plant
                _plantGrabbed[_plantGrabbedIndex] = false;
            }
        }