Example #1
0
    /// <summary>
    /// Check #4 for vertical potential matches
    /// </summary>
    /// <param name="row">Row of the object from which the check will be performed</param>
    /// <param name="column">Column of the object from which the check will be performed</param>
    /// <param name="shapes">Shapes array</param>
    /// <returns>List of objects for a potential match</returns>
    public static List <GameObject> CheckVertical4(int row, int column, ShapesArray shapes)
    {
        /* example
         * * * *     * * * *
         * * 2 *	 * 2 * *
         * 3 * *	 * * 3 *
         * * 1 *	 * 1 * *
         * * * *	 * * * *
         */
        List <GameObject> match = new List <GameObject>();

        if ((row <= Constants.Rows - 3) && shapes.IsSameType(row, column, 2, 0))
        {
            match.Add(shapes[row + 2, column]);

            if ((column >= 1) && shapes.IsSameType(row, column, 1, -1))
            {
                match.Add(shapes[row + 1, column - 1]);
            }

            else if ((column <= Constants.Columns - 2) && shapes.IsSameType(row, column, 1, 1))
            {
                match.Add(shapes[row + 1, column + 1]);
            }
        }

        return(match);
    }
Example #2
0
    /// <summary>
    /// Check #4 for horizontal potential matches
    /// </summary>
    /// <param name="row">Row of the object from which the check will be performed</param>
    /// <param name="column">Column of the object from which the check will be performed</param>
    /// <param name="shapes">Shapes array</param>
    /// <returns>List of objects for a potential match</returns>
    public static List <GameObject> CheckHorizontal4(int row, int column, ShapesArray shapes)
    {
        List <GameObject> match = new List <GameObject>();

        if ((column <= Constants.Columns - 3) && shapes.IsSameType(row, column, 0, 2))
        {
            match.Add(shapes[row, column + 2]);

            if ((row <= Constants.Rows - 2) && shapes.IsSameType(row, column, 1, 1))
            {
                match.Add(shapes[row + 1, column + 1]);

                /* * * * *
                * * 3 * *
                * 1 * 2 *
                * * * * */
            }

            else if ((row >= 1) && shapes.IsSameType(row, column, -1, 1))
            {
                match.Add(shapes[row - 1, column + 1]);

                /* * * * *
                * 1 * 2 *
                * * 3 * *
                * * * * */
            }
        }

        return(match);
    }
Example #3
0
    /// <summary>
    /// Check #1 for vertical potential matches
    /// </summary>
    /// <param name="row">Row of the object from which the check will be performed</param>
    /// <param name="column">Column of the object from which the check will be performed</param>
    /// <param name="shapes">Shapes array</param>
    /// <returns>List of objects for a potential match</returns>
    public static List <GameObject> CheckVertical1(int row, int column, ShapesArray shapes)
    {
        List <GameObject> match = new List <GameObject>();

        if ((row <= Constants.Rows - 4) && shapes.IsSameType(row, column, 3, 0))
        {
            match.Add(shapes[row + 3, column]);

            if (shapes.IsSameType(row, column, 1, 0))
            {
                match.Add(shapes[row + 1, column]);

                /* * *
                * 2 *
                * * *
                * 3 *
                * 1 *
                * * */

                if ((column <= Constants.Columns - 2) && shapes.IsSameType(row, column, 2, 1))
                {
                    match.Add(shapes[row + 2, column + 1]);

                    /* * * *
                    * 2 * *
                    * * 4 *
                    * 3 * *
                    * 1 * *
                    * * * */

                    if ((column <= Constants.Columns - 3) && shapes.IsSameType(row, column, 2, 2))
                    {
                        match.Add(shapes[row + 2, column + 2]);

                        /* * * * *
                        * 2 * * *
                        * * 4 5 *
                        * 3 * * *
                        * 1 * * *
                        * * * * */
                    }

                    if ((row <= Constants.Rows - 5) && shapes.IsSameType(row, column, 4, 0))
                    {
                        match.Add(shapes[row + 4, column]);

                        /* * * * *
                        * 5 * * *
                        * 2 * * *
                        * * 4 ? *
                        * 3 * * *
                        * 1 * * *
                        * * * * */
                    }
                }

                if ((column >= 1) && shapes.IsSameType(row, column, 2, -1))
                {
                    match.Add(shapes[row + 2, column - 1]);

                    /* * * * * *
                    * * ? * * *
                    * * 2 * * *
                    * 4 * ? ? *
                    * * 3 * * *
                    * * 1 * * *
                    * * * * * */

                    if ((column >= 2) && shapes.IsSameType(row, column, 2, -2))
                    {
                        match.Add(shapes[row + 2, column - 2]);

                        /* * * * * * *
                        * * * ? * * *
                        * * * 2 * * *
                        * 5 4 * ? ? *
                        * * * 3 * * *
                        * * * 1 * * *
                        * * * * * * */
                    }

                    if ((row <= Constants.Rows - 5) && shapes.IsSameType(row, column, 4, 0))
                    {
                        match.Add(shapes[row + 4, column]);

                        /* * * * * * *
                        * * * 5 * * *
                        * * * 2 * * *
                        * ? 4 * ? ? *
                        * * * 3 * * *
                        * * * 1 * * *
                        * * * * * * */
                    }
                }
            }

            else if (shapes.IsSameType(row, column, 2, 0))
            {
                match.Add(shapes[row + 2, column]);

                /* * *
                * 2 *
                * 3 *
                * * *
                * 1 *
                * * */

                if ((column <= Constants.Columns - 2) && shapes.IsSameType(row, column, 1, 1))
                {
                    match.Add(shapes[row + 1, column + 1]);

                    /* * * *
                    * 2 * *
                    * 3 * *
                    * * 4 *
                    * 1 * *
                    * * * */

                    if ((column <= Constants.Columns - 3) && shapes.IsSameType(row, column, 1, 2))
                    {
                        match.Add(shapes[row + 1, column + 2]);

                        /* * * * *
                        * 2 * * *
                        * 3 * * *
                        * * 4 5 *
                        * 1 * * *
                        * * * * */
                    }
                }

                if ((column >= 1) && shapes.IsSameType(row, column, 1, -1))
                {
                    match.Add(shapes[row + 1, column - 1]);

                    /* * * * * *
                    * * 2 * * *
                    * * 3 * * *
                    * 4 * ? ? *
                    * * 1 * * *
                    * * * * * */

                    if ((column >= 2) && shapes.IsSameType(row, column, 1, -2))
                    {
                        match.Add(shapes[row + 1, column - 2]);

                        /* * * * * * *
                        * * * 2 * * *
                        * * * 3 * * *
                        * 5 4 * ? ? *
                        * * * 1 * * *
                        * * * * * * */
                    }
                }
            }
        }

        return(match);
    }
Example #4
0
    /// <summary>
    /// Check #1 for horizontal potential matches
    /// </summary>
    /// <param name="row">Row of the object from which the check will be performed</param>
    /// <param name="column">Column of the object from which the check will be performed</param>
    /// <param name="shapes">Shapes array</param>
    /// <returns>List of objects for a potential match</returns>
    public static List <GameObject> CheckHorizontal1(int row, int column, ShapesArray shapes)
    {
        List <GameObject> match = new List <GameObject>();

        if ((column <= Constants.Columns - 4) && shapes.IsSameType(row, column, 0, 3))
        {
            match.Add(shapes[row, column + 3]);

            if (shapes.IsSameType(row, column, 0, 1))
            {
                match.Add(shapes[row, column + 1]);

                /* * * * * *
                * 1 3 * 2 *
                * * * * * */

                if ((row <= Constants.Rows - 2) && shapes.IsSameType(row, column, 1, 2))
                {
                    match.Add(shapes[row + 1, column + 2]);

                    /* * * * * *
                    * * * 4 * *
                    * 1 3 * 2 *
                    * * * * * */

                    if ((row <= Constants.Rows - 3) && shapes.IsSameType(row, column, 2, 2))
                    {
                        match.Add(shapes[row + 2, column + 2]);

                        /* * * * * *
                        * * * 5 * *
                        * * * 4 * *
                        * 1 3 * 2 *
                        * * * * * */
                    }

                    if ((column <= Constants.Columns - 5) && shapes.IsSameType(row, column, 0, 4))
                    {
                        match.Add(shapes[row, column + 4]);

                        /* * * * * * *
                        * * * ? * * *
                        * * * 4 * * *
                        * 1 3 * 2 5 *
                        * * * * * * */
                    }
                }
                if ((row >= 1) && shapes.IsSameType(row, column, -1, 2))
                {
                    match.Add(shapes[row - 1, column + 2]);

                    /* * * * * * *
                    * * * ? * * *
                    * * * ? * * *
                    * 1 3 * 2 ? *
                    * * * 4 * * *
                    * * * * * * */

                    if ((row >= 2) && shapes.IsSameType(row, column, -2, 2))
                    {
                        match.Add(shapes[row - 2, column + 2]);

                        /* * * * * * *
                        * * * ? * * *
                        * * * ? * * *
                        * 1 3 * 2 ? *
                        * * * 4 * * *
                        * * * 5 * * *
                        * * * * * * */
                    }

                    if ((column <= Constants.Columns - 5) && shapes.IsSameType(row, column, 0, 4))
                    {
                        match.Add(shapes[row, column + 4]);

                        /* * * * * * *
                        * * * ? * * *
                        * * * ? * * *
                        * 1 3 * 2 5 *
                        * * * 4 * * *
                        * * * ? * * *
                        * * * * * * */
                    }
                }
            }

            else if (shapes.IsSameType(row, column, 0, 2))
            {
                match.Add(shapes[row, column + 2]);

                /* * * * * *
                * 1 * 3 2 *
                * * * * * */

                if ((row <= Constants.Rows - 2) && shapes.IsSameType(row, column, 1, 1))
                {
                    match.Add(shapes[row + 1, column + 1]);

                    /* * * * * *
                    * * 4 * * *
                    * 1 * 3 2 *
                    * * * * * */

                    if ((row <= Constants.Rows - 3) && shapes.IsSameType(row, column, 2, 1))
                    {
                        match.Add(shapes[row + 2, column + 1]);

                        /* * * * * *
                        * * 5 * * *
                        * * 4 * * *
                        * 1 * 3 2 *
                        * * * * * */
                    }
                }
                if ((row >= 1) && shapes.IsSameType(row, column, -1, 1))
                {
                    match.Add(shapes[row - 1, column + 1]);

                    /* * * * * *
                    * * ? * * *
                    * * ? * * *
                    * 1 * 3 2 *
                    * * 4 * * *
                    * * * * * */

                    if ((row >= 2) && shapes.IsSameType(row, column, -2, 1))
                    {
                        match.Add(shapes[row - 2, column + 1]);

                        /* * * * * *
                        * * ? * * *
                        * * ? * * *
                        * 1 * 3 2 *
                        * * 4 * * *
                        * * 5 * * *
                        * * * * * */
                    }
                }
            }
        }

        return(match);
    }