Esempio n. 1
0
 //交换两甜品(添加不符合条件回退功能)
 private void ExchangeSweets(GameSweet sweet1, GameSweet sweet2)
 {
     if (sweet1.CanMove() && sweet2.CanMove())
     {
         ////如果横向和纵向交换后都没有可消除的糖果,交换位置重新归位
         if (MatchSweet(sweet1, sweet2.X, sweet2.Y) != null || MatchSweet(sweet2, sweet1.X, sweet1.Y) != null)
         {
             int TempX = sweet1.X;
             int TempY = sweet1.Y;
             sweet1.MoveComponent.Move(sweet2.X, sweet2.Y, fileTime);
             sweet2.MoveComponent.Move(TempX, TempY, fileTime);
             sweets[sweet1.X, sweet1.Y] = sweet2;
             sweets[sweet2.X, sweet2.Y] = sweet1;
         }
         else
         {
             //两个糖果先进行交换
             int TempX = sweet1.X;
             int TempY = sweet1.Y;
             sweet1.MoveComponent.Move(sweet2.X, sweet2.Y, fileTime);
             sweet2.MoveComponent.Move(TempX, TempY, fileTime);
             StartCoroutine(ClearChangge(sweet2, sweet1));
         }
     }
 }
Esempio n. 2
0
    //交换甜品的方法

    private void ExchangeSweets(GameSweet sweet1, GameSweet sweet2)
    {
        if (sweet1.CanMove() && sweet2.CanMove())
        {
            sweets[sweet1.X, sweet1.Y] = sweet2;
            sweets[sweet2.X, sweet2.Y] = sweet1;
            //有返回的删除列表
            if (MatchSweets(sweet1, sweet2.X, sweet2.Y) != null || MatchSweets(sweet2, sweet1.X, sweet1.Y) != null)
            {
                //先交换两个元素
                int tempX = sweet1.X;
                int tempY = sweet1.Y;

                sweet1.MoveComponent.Move(sweet2.X, sweet2.Y, time);
                sweet2.MoveComponent.Move(tempX, tempY, time);
                //清除
                ClearAllMatchSweet();
                //填充
                StartCoroutine(AllFill());
            }
            else
            {
                //不做处理
                sweets[sweet1.X, sweet1.Y] = sweet1;
                sweets[sweet2.X, sweet2.Y] = sweet2;
            }
        }
    }
Esempio n. 3
0
    /// <summary>
    /// 交换两个甜品的方法
    /// </summary>
    public void ExchangeSweets(GameSweet sweet1, GameSweet sweet2)
    {
        if (sweet1.CanMove() && sweet2.CanMove())
        {
            sweets[sweet1.X, sweet1.Y] = sweet2;
            sweets[sweet2.X, sweet2.Y] = sweet1;

            if (MatchSweets(sweet1, sweet2.X, sweet2.Y) != null || MatchSweets(sweet2, sweet1.X, sweet1.Y) != null)
            {
                int tempX = sweet1.X;
                int tempy = sweet1.Y;
                sweet1.MovedComponent.Move(sweet2.X, sweet2.Y, fillTime);
                sweet2.MovedComponent.Move(tempX, tempy, fillTime);



                ClearAllMatchedSweet();
                StartCoroutine(AllFill());

                pressedSweet = null;
                enteredSweet = null;
            }
            else
            {
                sweets[sweet1.X, sweet1.Y] = sweet1;
                sweets[sweet2.X, sweet2.Y] = sweet2;
            }
        }
    }
Esempio n. 4
0
    //鼠标操作交换位置时
    public void ExChangeSweets(GameSweet sweetOnclick1, GameSweet sweetOnclick2)
    {
        if (sweetOnclick1.Equals(sweetOnclick2))
        {
            return;
        }
        if (sweetOnclick1.CanMove() && sweetOnclick2.CanMove())
        {
            sweetsarray[sweetOnclick1.Y, sweetOnclick1.X] = sweetOnclick2;
            sweetsarray[sweetOnclick2.Y, sweetOnclick2.X] = sweetOnclick1;//记录位子更新

            if (MatchSweets(sweetOnclick1, sweetOnclick2.X, sweetOnclick2.Y) != null ||
                MatchSweets(sweetOnclick2, sweetOnclick1.X, sweetOnclick1.Y) != null ||
                sweetOnclick1.Type == SweetsType.RAINBOWCANDY ||
                sweetOnclick2.Type == SweetsType.RAINBOWCANDY)//可以交换时
            {
                sweetsarray[sweetOnclick1.Y, sweetOnclick1.X] = sweetOnclick2;
                sweetsarray[sweetOnclick2.Y, sweetOnclick2.X] = sweetOnclick1;//记录位子更新

                int tempx = sweetOnclick1.X
                , tempy   = sweetOnclick1.Y;
                sweetOnclick1.MoveComponent.Move(sweetOnclick2.X, sweetOnclick2.Y, fillTime);
                sweetOnclick2.MoveComponent.Move(tempx, tempy, fillTime);

                if (sweetOnclick1.Type == SweetsType.RAINBOWCANDY && sweetOnclick1.CanClear() && sweetOnclick2.CanClear())
                {
                    ClearColorSweet clearcolor = sweetOnclick1.GetComponent <ClearColorSweet>();
                    if (clearcolor != null)
                    {
                        clearcolor.ClearColor = sweetOnclick2.ColorComponent.Color;
                    }
                    ClearSweet(sweetOnclick1.X, sweetOnclick1.Y);
                }

                if (sweetOnclick2.Type == SweetsType.RAINBOWCANDY && sweetOnclick1.CanClear() && sweetOnclick2.CanClear())
                {
                    ClearColorSweet clearcolor = sweetOnclick2.GetComponent <ClearColorSweet>();
                    if (clearcolor != null)
                    {
                        clearcolor.ClearColor = sweetOnclick1.ColorComponent.Color;
                    }
                    ClearSweet(sweetOnclick2.X, sweetOnclick2.Y);
                }
                pressedSweet = null;
                enteredSweet = null;
                ClearAllMatchedSweet();
                StartCoroutine(AllFill());
            }
            else
            {
                sweetsarray[sweetOnclick1.Y, sweetOnclick1.X] = sweetOnclick1;
                sweetsarray[sweetOnclick2.Y, sweetOnclick2.X] = sweetOnclick2;//记录位子更新
            }
        }
    }
Esempio n. 5
0
    //交换两个甜品的方法
    private void ExchangeSweets(GameSweet sweet1, GameSweet sweet2)
    {
        if (sweet1.CanMove() && sweet2.CanMove())
        {
            sweets[sweet1.X, sweet1.Y] = sweet2;
            sweets[sweet2.X, sweet2.Y] = sweet1;

            if (MatchSweets(sweet1, sweet2.X, sweet2.Y) != null || MatchSweets(sweet2, sweet1.X, sweet1.Y) != null || sweet1.Type == SweetsType.RAINBOWCANDY || sweet2.Type == SweetsType.RAINBOWCANDY)
            {
                int tempX = sweet1.X;
                int tempY = sweet1.Y;


                sweet1.MovedComponent.Move(sweet2.X, sweet2.Y, fillTime);
                sweet2.MovedComponent.Move(tempX, tempY, fillTime);

                if (sweet1.Type == SweetsType.RAINBOWCANDY && sweet1.CanClear() && sweet2.CanClear())
                {
                    ClearColorSweet clearColor = sweet1.GetComponent <ClearColorSweet>();

                    if (clearColor != null)
                    {
                        clearColor.ClearColor = sweet2.ColoredComponent.Color;
                    }

                    ClearSweet(sweet1.X, sweet1.Y);
                }

                if (sweet2.Type == SweetsType.RAINBOWCANDY && sweet2.CanClear() && sweet1.CanClear())
                {
                    ClearColorSweet clearColor = sweet2.GetComponent <ClearColorSweet>();

                    if (clearColor != null)
                    {
                        clearColor.ClearColor = sweet1.ColoredComponent.Color;
                    }

                    ClearSweet(sweet2.X, sweet2.Y);
                }


                ClearAllMatchedSweet();
                StartCoroutine(AllFill());

                pressedSweet = null;
                enteredSweet = null;
            }
            else
            {
                sweets[sweet1.X, sweet1.Y] = sweet1;
                sweets[sweet2.X, sweet2.Y] = sweet2;
            }
        }
    }
Esempio n. 6
0
    /// <summary>
    /// 交换物品位置
    /// </summary>
    /// <param name="sweet1"></param>
    /// <param name="sweet2"></param>
    private void ExChangeSweets(GameSweet sweet1, GameSweet sweet2)
    {
        if (sweet1.CanMove() && sweet2.CanMove())         //如果2个物品都能移动
        {
            sweets[sweet1.X, sweet1.Y] = sweet2;
            sweets[sweet2.X, sweet2.Y] = sweet1;

            if (MatchSweets(sweet1, sweet2.X, sweet2.Y) != null ||
                MatchSweets(sweet2, sweet1.X, sweet1.Y) != null ||
                sweet1.Type == SweetsType.RAINBOWCANDY ||
                sweet2.Type == SweetsType.RAINBOWCANDY)                                         //如果完成匹配
            {
                int tempX = sweet1.X;
                int tempY = sweet1.Y;

                sweet1.MovedComponet.Move(sweet2.X, sweet2.Y, fillTime);
                sweet2.MovedComponet.Move(tempX, tempY, fillTime);

                if (sweet1.Type == SweetsType.RAINBOWCANDY && sweet1.CanClear() && sweet2.CanClear())                 //如果物品1是 特殊物品:消除颜色
                {
                    ClearColorSweet clearColor = sweet1.GetComponent <ClearColorSweet>();
                    if (clearColor != null)                     //容错
                    {
                        clearColor.ClearColor = sweet2.ColorComponet.Color;
                    }
                    ClearSweet(sweet1.X, sweet1.Y);
                }
                if (sweet2.Type == SweetsType.RAINBOWCANDY && sweet2.CanClear() && sweet2.CanClear())                 //如果物品2是 特殊物品:消除颜色
                {
                    ClearColorSweet clearColor = sweet2.GetComponent <ClearColorSweet>();
                    if (clearColor != null)
                    {
                        clearColor.ClearColor = sweet1.ColorComponet.Color;
                    }
                    ClearSweet(sweet2.X, sweet2.Y);
                }


                ClearAllMatchedSweet();                    //交换位置后,清除物品,并生成空格
                StartCoroutine(AllFill());                 //交换位置后填充

                pressedSweet = null;
                enterSweet   = null;
            }
            else
            {
                sweets[sweet1.X, sweet1.Y] = sweet1;
                sweets[sweet2.X, sweet1.Y] = sweet2;
            }
        }
    }
Esempio n. 7
0
    //交换两个甜品的方法
    private void ExChangeSweets(GameSweet sweet1, GameSweet sweet2)
    {
        if (sweet1.CanMove() && sweet2.CanMove())
        {
            sweets[sweet1.X, sweet1.Y] = sweet2;
            sweets[sweet2.X, sweet2.Y] = sweet1;

            int tempX = sweet1.X;
            int tempY = sweet1.Y;

            sweet1.MovedComponent.Move(sweet2.X, sweet2.Y, fillTime);
            sweet2.MovedComponent.Move(tempX, tempY, fillTime);
        }
    }
Esempio n. 8
0
    /// <summary>
    /// 将两个甜品位置交换
    /// </summary>
    /// <param name="sweet1"></param>
    /// <param name="sweet2"></param>
    private void ExchangeSweets(GameSweet sweet1, GameSweet sweet2)
    {
        if (sweet1.CanMove() && sweet2.CanMove())
        {
            sweets[sweet1.X, sweet1.Y] = sweet2;
            sweets[sweet2.X, sweet2.Y] = sweet1;
            int tempX = sweet1.X;
            int tempY = sweet1.Y;
            if (MatchSweets(sweet1, sweet2.X, sweet2.Y) != null || MatchSweets(sweet2, sweet1.X, sweet1.Y) != null || sweet1.Type == SweetType.RAINBOWCANDY || sweet2.Type == SweetType.RAINBOWCANDY)
            {
                //如果匹配到了最少三个相同的甜品则交换位置,且不能返回之前的位置
                sweet1.MoveSweetComponent.Move(sweet2.X, sweet2.Y, fillTime);//由于两个携程会影响甜品的位置,因此之前要先记录之前的位置
                sweet2.MoveSweetComponent.Move(tempX, tempY, fillTime);
                //如果两个甜品中有最少一个彩虹糖也可进入该语句
                if (sweet1.Type == SweetType.RAINBOWCANDY && sweet1.CanClear() && sweet2.CanClear())
                {
                    ClearSameSweet clearColor = sweet1.GetComponent <ClearSameSweet>();

                    if (clearColor != null)
                    {
                        clearColor.Color = sweet2.ColorSweetComponent.Color;
                    }
                    ClearSweet(sweet1.X, sweet1.Y);
                }

                if (sweet2.Type == SweetType.RAINBOWCANDY && sweet2.CanClear() && sweet1.CanClear())
                {
                    ClearSameSweet clearColor = sweet2.GetComponent <ClearSameSweet>();

                    if (clearColor != null)
                    {
                        clearColor.Color = sweet1.ColorSweetComponent.Color;
                    }
                    ClearSweet(sweet2.X, sweet2.Y);
                }

                ClearAllMatchSweet();
                StartCoroutine(AllFill());
            }
            else
            {
                //如果没匹配到三个相同的三个元素,则先交换后返回
                sweets[sweet1.X, sweet1.Y] = sweet1;
                sweets[sweet2.X, sweet2.Y] = sweet2;
                sweet1.MoveSweetComponent.Move(sweet2.X, sweet2.Y, fillTime);//由于两个携程会影响甜品的位置,因此之前要先记录之前的位置
                sweet2.MoveSweetComponent.Move(tempX, tempY, fillTime);
                StartCoroutine(Wait(0.5f, sweet1, sweet2));
            }
        }
    }
Esempio n. 9
0
 /// <summary>
 /// 两个甜品位置交换
 /// </summary>
 public void ExChangeSweet(GameSweet sweet1, GameSweet sweet2)
 {
     if (sweet1.CanMove() && sweet2.CanMove())
     {
         sweetArr[sweet1.X, sweet1.Y] = sweet2;
         sweetArr[sweet2.X, sweet2.Y] = sweet1;
         if (MatchSweets(sweet1, sweet2.X, sweet2.Y) != null || MatchSweets(sweet2, sweet1.X, sweet1.Y) != null || sweet1.Type == SweetsType.RainbowCandy || sweet2.Type == SweetsType.RainbowCandy)
         {
             //记录x、y的值 防止sweet1已移动完成后位置跟sweet2重叠
             var x = sweet1.X;
             var y = sweet1.Y;
             sweet1.moveSweet.Move(sweet2.X, sweet2.Y, fillTime);
             sweet2.moveSweet.Move(x, y, fillTime);
             //清除指定颜色所有甜品
             if (sweet1.Type == SweetsType.RainbowCandy && sweet1.CanClear() && sweet2.CanClear())
             {
                 ClearColorSweet clearColor = sweet1.GetComponent <ClearColorSweet>();
                 if (clearColor != null)
                 {
                     clearColor.ClearColor = sweet2.colorSweet.colorType;
                 }
                 ClearSweet(sweet1.X, sweet1.Y);
             }
             if (sweet2.Type == SweetsType.RainbowCandy && sweet1.CanClear() && sweet2.CanClear())
             {
                 ClearColorSweet clearColor = sweet2.GetComponent <ClearColorSweet>();
                 if (clearColor != null)
                 {
                     clearColor.ClearColor = sweet1.colorSweet.colorType;
                 }
                 ClearSweet(sweet2.X, sweet2.Y);
             }
             ClearAllMatchedSweet();
             StartCoroutine(AllFill());
             clickSweet = null;
             enterSweet = null;
         }
         else
         {
             sweetArr[sweet1.X, sweet1.Y] = sweet1;
             sweetArr[sweet2.X, sweet2.Y] = sweet2;
         }
     }
 }
Esempio n. 10
0
    //交换两个甜品
    private void ExchangeSweets(GameSweet sweet1, GameSweet sweet2)
    {
        if (sweet1.CanMove() && sweet2.CanMove())
        {
            sweets[sweet1.X, sweet1.Y] = sweet2;
            sweets[sweet2.X, sweet2.Y] = sweet1;

            if (MatchSweet(sweet1, sweet2.X, sweet2.Y) != null || MatchSweet(sweet2, sweet1.X, sweet1.Y) != null)
            {
                //先做缓存一下,要不然下面会把1的位置覆盖掉。
                int tempX = sweet1.X;
                int tempY = sweet1.Y;

                sweet1.MovedComponent.Move(sweet2.X, sweet2.Y, fillTime);
                sweet2.MovedComponent.Move(tempX, tempY, fillTime);
            }
            else
            {
                sweets[sweet1.X, sweet1.Y] = sweet1;
                sweets[sweet2.X, sweet2.Y] = sweet2;
            }
        }
    }
Esempio n. 11
0
    /// <summary>
    /// 分步填充
    /// </summary>
    public bool Fill()
    {
        bool filledNotFinished = false;    //判断本次的填充是否完成;

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColum; x++)
            {
                GameSweet sweet = sweets[x, y]; //得到当前的元素的位置
                if (sweet.CanMove())            //如果无法移动,则无法向下填充
                {
                    GameSweet sweetBelow = sweets[x, y + 1];

                    if (sweetBelow.Type == SweetType.EMPTY)  //垂直填充
                    {
                        Destroy(sweetBelow.gameObject);
                        sweet.MovedComponent.Move(x, y + 1, fillTime);
                        sweets[x, y + 1] = sweet;
                        CreateNewSweet(x, y, SweetType.EMPTY);
                        filledNotFinished = true;
                    }
                    else        //斜向填充
                    {
                        for (int down = -1; down < 1; down++)
                        {
                            if (down != 0)
                            {
                                int downX = down + x;
                                //该处判断列的位置    0 < downX < xColum
                                //   [0,0]     [1,0]   [2,0] ...[x,0]
                                //   [1,0]     [1,1]   [1,2] ...[1,yRow]
                                //   ...        ...
                                //[xColum,0] [xColum] [xColum]...[xColum]
                                if (downX > 0 && downX < xColum)
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];
                                    if (downSweet.Type == SweetType.EMPTY)
                                    {
                                        bool canFill = true;

                                        //判断数值方向上是否符合填充的要求
                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];

                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetType.EMPTY)
                                            {
                                                canFill = false;
                                                break;
                                            }
                                        }
                                        if (!canFill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MovedComponent.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetType.EMPTY);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            //最上排 特殊情况
            for (int x = 0; x < xColum; x++)
            {
                GameSweet sweet = sweets[x, 0];
                if (sweet.Type == SweetType.EMPTY)
                {
                    GameObject newSweet = Instantiate(sweetPrefabDic[SweetType.NORMAL], CorrectPos(x, -1), Quaternion.identity);
                    newSweet.transform.parent = transform;

                    sweets[x, 0] = newSweet.GetComponent <GameSweet>();
                    sweets[x, 0].Init(x, -1, this, SweetType.NORMAL);
                    sweets[x, 0].MovedComponent.Move(x, 0, fillTime);
                    sweets[x, 0].ColoredComponent.SetColor((ColorSweet.ColorType)Random.Range(0, sweets[x, 0].ColoredComponent.NumColors));
                    filledNotFinished = true;
                }
            }
        }
        return(filledNotFinished);
    }
Esempio n. 12
0
    //清除完成匹配的元素
    public bool ClearAllMatchSweet()
    {
        bool needReFill = false;

        for (int y = 0; y < yRow; y++)
        {
            for (int x = 0; x < xColumn; x++)
            {
                if (sweets[x, y].CanClear())
                {
                    // 返回的需要删除的元素列表
                    List <GameSweet> matchList = MatchSweets(sweets[x, y], x, y);
                    if (matchList != null)
                    {
                        // Debug.Log("消除列表长度="+matchList.Count);
                        SweetType specialSweetType = SweetType.COUNT;
                        //在随机一个消除位置生成一个行消除或者列消除
                        GameSweet birthSpecialSweet = matchList[Random.Range(0, matchList.Count)];
                        int       specialX          = birthSpecialSweet.X;
                        int       specialY          = birthSpecialSweet.Y;
                        if (matchList.Count == 4)
                        {
                            // Debug.Log("开始产生特殊物品!!!!!!!!!!!!!!!");
                            //随机一个行消除或者列消除
                            specialSweetType = (SweetType)Random.Range((int)SweetType.ROW_CLEAR, (int)SweetType.RAINBOWCANDY);
                        }

                        for (int i = 0; i < matchList.Count; i++)
                        {
                            //if (matchList[i] == null)
                            //    continue;
                            if (ClearSweet(matchList[i].X, matchList[i].Y))
                            {
                                needReFill = true;
                            }
                        }

                        if (specialSweetType != SweetType.COUNT)
                        {
                            //Debug.Log("开始产生特殊物品");
                            Destroy(sweets[specialX, specialY]);
                            GameSweet newSweet = CreatNewSweet(specialX, specialY, specialSweetType);
                            if (specialSweetType == SweetType.ROW_CLEAR || specialSweetType == SweetType.COLUMN_CLEAR && newSweet.CanMove() && matchList[0].CanColor())
                            {
                                //newSweet.ColorComponent.SetColor(matchList[0].ColorComponent.Color);
                            }
                            else
                            {
                            }
                        }
                    }
                }
            }
        }
        return(needReFill);
    }
Esempio n. 13
0
    //分步填充
    private bool Fill()
    {
        bool filledNotFinished = false;//这个部分布尔值是用来判断本次填充是否完成。

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColumn; x++)
            {
                GameSweet sweet = sweets[x, y];
                if (sweet.CanMove())//如果无法移动,则无法往下填充
                {
                    GameSweet sweetBelow = sweets[x, y + 1];
                    //垂直填充
                    if (sweetBelow.Type == SweetsType.EMPTY)
                    {
                        sweet.MovedComponent.Move(x, y + 1, fillTime);
                        sweets[x, y + 1] = sweet;
                        Destroy(sweetBelow.gameObject);
                        //填充上面哪行
                        CreateNewSweet(x, y, SweetsType.EMPTY);

                        filledNotFinished = true;
                    }
                    else
                    {
                        //斜方向填充
                        //如果不可以移动,就查看坐下和右下是否可以移动
                        for (int i = -1; i <= 1; i++)
                        {
                            int downX = x + i;

                            if (i != 0)
                            {
                                if (downX >= 0 && downX < xColumn)
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];
                                    if (downSweet.Type == SweetsType.EMPTY)
                                    {
                                        bool canFill = true;
                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];
                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetsType.EMPTY)
                                            {
                                                canFill = false;
                                                break;
                                            }
                                        }

                                        if (!canFill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MovedComponent.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetsType.EMPTY);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                if (y == 0 && sweet.Type == SweetsType.EMPTY)
                {
                    GameObject newSweetObject = Instantiate(sweetPrefabDict[SweetsType.NORMAL], CorrectPosition(x, y - 1), Quaternion.identity);
                    newSweetObject.transform.SetParent(transform);

                    GameSweet sweetComponent = newSweetObject.GetComponent <GameSweet>();
                    sweetComponent.Init(x, y - 1, this, SweetsType.NORMAL);

                    sweetComponent.MovedComponent.Move(x, y, fillTime);
                    sweetComponent.ColorComponent.SetColor((ColorSweet.ColorType)Random.Range(0, sweetComponent.ColorComponent.numColors));

                    sweets[x, y] = sweetComponent;

                    //销毁空物体
                    Destroy(sweet.gameObject);

                    filledNotFinished = true;
                }
            }
        }

        return(filledNotFinished);
    }
Esempio n. 14
0
    //分步填充的方法
    public bool Fill()
    {
        bool filledNotFinished = false;////判断本次填充是否完成

        //最后一行不遍历,因为它不需要往下填充
        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColumn; x++)
            {
                //取到当前元素
                GameSweet sweet = sweets[x, y];
                //如果无法移动则无法向下填充
                if (sweet.CanMove())
                {
                    //获取到当前元素下方的元素
                    GameSweet sweetBelow = sweets[x, y + 1];
                    //如果下方元素为空,上方元素向下填充
                    if (sweetBelow.Type == SweetType.EMPTY)
                    {
                        //垂直填充
                        sweet.MoveComponent.Move(x, y + 1, time);
                        //将其保存在数组当中
                        sweets[x, y + 1] = sweet;
                        //将当前元素的位置滞空
                        CreatNewSweet(x, y, SweetType.EMPTY);
                        filledNotFinished = true;
                    }
                    else
                    {
                        //斜向填充
                        for (int down = -1; down <= 1; down++)
                        {
                            if (down != 0)
                            {
                                int downX = x + down;
                                if (downX > 0 && downX < xColumn)
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];
                                    if (downSweet.Type == SweetType.EMPTY)
                                    {
                                        bool canFill = true;
                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];
                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetType.EMPTY)
                                            {
                                                canFill = false;
                                                break;
                                            }
                                        }
                                        if (!canFill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MoveComponent.Move(downX, y + 1, time);
                                            sweets[downX, y + 1] = sweet;
                                            CreatNewSweet(x, y, SweetType.EMPTY);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        //最上层的特殊情况
        for (int x = 0; x < xColumn; x++)
        {
            //获取到最上层元素对象
            GameSweet sweet = sweets[x, 0];
            //如果当前的元素为空
            if (sweet.Type == SweetType.EMPTY)
            {
                GameObject newSweet = Instantiate(sweetPrefabDict[SweetType.NORMAL], CorrectPosition(x, -1), Quaternion.identity);
                newSweet.transform.SetParent(transform);
                sweets[x, 0] = newSweet.GetComponent <GameSweet>();
                sweets[x, 0].Init(x, -1, this, SweetType.NORMAL);
                sweets[x, 0].MoveComponent.Move(x, 0, time);
                sweets[x, 0].ColorComponent.SetColor((ColorSweet.ColorType)Random.Range(0, sweets[x, 0].ColorComponent.GetNumColor));
                filledNotFinished = true;
            }
        }
        return(filledNotFinished);
    }
Esempio n. 15
0
    /// <summary>
    /// 填充,循环一轮
    /// </summary>
    public bool Fill()
    {
        bool filledNotFinished = false;//判断本次是否填充完成

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColumn; x++)
            {
                GameSweet sweet = sweets[x, y];              //得到当前元素位置的甜品对象
                if (sweet.CanMove())                         //如果可以移动
                {
                    GameSweet sweetBelow = sweets[x, y + 1]; //获取下一行位置
                    if (sweetBelow.Type == SweetType.EMPTY)  //如果为空,则往下填充
                    {
                        //Destroy(sweetBelow.gameObject);可保护可不保护
                        sweet.MovedComponent.Move(x, y + 1, fillTime);
                        sweets[x, y + 1] = sweet;              //下一行等于当前行的东西
                        CreateNewSweet(x, y, SweetType.EMPTY); //移动之后把自身置空
                        filledNotFinished = true;              //自身格子判断填充未完成
                    }
                    else//否则向左下角,右下角移动
                    {
                        for (int down = -1; down <= 1; down++)  //-1左边 0当前 1右边
                        {
                            if (down != 0)
                            {
                                int downX = x + down;
                                if (downX >= 0 && downX < xColumn)//判断是否在最左跟最右列之间,是才移动
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];
                                    if (downSweet.Type == SweetType.EMPTY)
                                    {
                                        bool canfill = true;                        //用来判断垂直填充是否可以满足填充要求
                                        for (int aboveY = y; aboveY >= 0; aboveY--) //当前y行  ,  从下往上遍历
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];
                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetType.EMPTY)
                                            {
                                                canfill = false;
                                                break;
                                            }
                                        }
                                        if (!canfill)//如果垂直填充不满足,则斜向填充
                                        {
                                            //Destroy(downSweet.gameObject);可保护可不保护
                                            sweet.MovedComponent.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;          //填充
                                            CreateNewSweet(x, y, SweetType.EMPTY); //将原来格子置空
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        //最上排的特殊情况
        for (int x = 0; x < xColumn; x++)
        {
            GameSweet sweet = sweets[x, 0];                                                                                        //获取最上行的甜品对象
            if (sweet.Type == SweetType.EMPTY)                                                                                     //最上行是否为空
            {
                GameObject newSweet = Instantiate(sweetPrefabDict[SweetType.NORMAL], CorrectPosition(x, -1), Quaternion.identity); //实例化-1行(生成)
                newSweet.transform.parent = transform;

                sweets[x, 0] = newSweet.GetComponent <GameSweet>();                                                          //当前行拿到组件
                sweets[x, 0].Init(x, -1, this, SweetType.NORMAL);                                                            //初始化
                sweets[x, 0].MovedComponent.Move(x, 0, fillTime);                                                            //移动到第一行,位置脚本
                sweets[x, 0].ColoredComponent.SetColor((ColorType)Random.Range(0, sweets[x, 0].ColoredComponent.NumColors)); //随机设置什么颜色类型的甜品,由于参数是ColorSweet脚本组件的枚举类型
                filledNotFinished = true;
            }
        }
        return(filledNotFinished);
    }
Esempio n. 16
0
    /// <summary>
    /// 分步填充
    /// </summary>
    public bool Fill()
    {
        //判断本次填充是否完成
        bool filledNotFinished = false;

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xCol; x++)
            {
                GameSweet sweet = sweetArr[x, y];
                //判断是否可以移动,如果不能移动则无法向下填充
                if (sweet.CanMove() == true)
                {
                    //获取当前甜品下面的甜品
                    GameSweet sweetBelow = sweetArr[x, y + 1];
                    //垂直填充
                    if (sweetBelow.Type == SweetsType.Empty)
                    {
                        Destroy(sweetBelow.gameObject);
                        //移动当前甜品
                        sweet.moveSweet.Move(x, y + 1, fillTime);
                        sweetArr[x, y + 1] = sweet;
                        //在当前位置创建甜品
                        CreateNewSweet(x, y, SweetsType.Empty);
                        filledNotFinished = true;
                    }
                    //斜向填充
                    else
                    {
                        //-1 向左 1向右 0垂直
                        for (int down = -1; down <= 1; down++)
                        {
                            if (down != 0)
                            {
                                //新的x坐标
                                int downX = x + down;
                                if (downX >= 0 && downX < xCol)
                                {
                                    //获取游戏对象
                                    GameSweet downSweet = sweetArr[downX, y + 1];
                                    if (downSweet.Type == SweetsType.Empty)
                                    {
                                        //是否可以移动标识
                                        bool canFill = true;
                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            //获取游戏对象
                                            GameSweet aboveSweet = sweetArr[downX, aboveY];
                                            if (aboveSweet.CanMove() == true)
                                            {
                                                break;
                                            }
                                            else if (aboveSweet.CanMove() == false && aboveSweet.Type != SweetsType.Empty)
                                            {
                                                canFill = false;
                                                break;
                                            }
                                        }
                                        if (!canFill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.moveSweet.Move(downX, y + 1, fillTime);
                                            sweetArr[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetsType.Empty);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        //最上排的特殊情况处理
        for (int x = 0; x < xCol; x++)
        {
            GameSweet sweet = sweetArr[x, 0];
            if (sweet.Type == SweetsType.Empty)
            {
                GameObject newSweet = Instantiate(prefabDic[SweetsType.Normal], CorrectPos(x, -1), Quaternion.identity);
                newSweet.transform.parent = transform;
                //获取基础脚本并初始化
                sweetArr[x, 0] = newSweet.GetComponent <GameSweet>();
                sweetArr[x, 0].Init(x, -1, this, SweetsType.Normal);
                if (sweetArr[x, 0].CanMove())
                {
                    sweetArr[x, 0].moveSweet.Move(x, 0, fillTime);
                }
                if (sweetArr[x, 0].CanColor())
                {
                    sweetArr[x, 0].colorSweet.SetSprite((ColorType)Random.Range(0, sweetArr[x, 0].colorSweet.spriteDic.Count));
                }
                filledNotFinished = true;
            }
        }
        return(filledNotFinished);
    }
    public bool Fill()
    {
        bool filledNotFinished = false;

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int loopX = 0; loopX < xColumn; loopX++)
            {
                int x = loopX;
                if (inverse)
                {
                    x = xColumn - 1 - loopX;
                }

                GameSweet sweet = sweets[x, y];

                if (sweet.CanMove())
                {
                    GameSweet sweetBelow = sweets[x, y + 1];

                    if (sweetBelow.Type == SweetsType.EMPTY)
                    {
                        Destroy(sweetBelow.gameObject);
                        sweet.MovedComponent.Move(x, y + 1, fillTime);
                        sweets[x, y + 1] = sweet;
                        CreateNewSweet(x, y, SweetsType.EMPTY);
                        filledNotFinished = true;
                    }
                    else
                    {
                        for (int down = -1; down <= 1; down++)
                        {
                            if (down != 0)
                            {
                                int downX = x + down;

                                if (inverse)
                                {
                                    downX = x - down;
                                }

                                if (downX >= 0 && downX < xColumn)
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];

                                    if (downSweet.Type == SweetsType.EMPTY)
                                    {
                                        bool canfill = true;

                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];

                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetsType.EMPTY)
                                            {
                                                canfill = false;
                                                break;
                                            }
                                        }

                                        if (!canfill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MovedComponent.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetsType.EMPTY);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        for (int x = 0; x < xColumn; x++)
        {
            GameSweet sweet = sweets[x, 0];

            if (sweet.Type == SweetsType.EMPTY)
            {
                GameObject newSweet = Instantiate(sweetPrefabDict[SweetsType.NORMAL], CorrectPositon(x, -1), Quaternion.identity);
                newSweet.transform.parent = transform;

                sweets[x, 0] = newSweet.GetComponent <GameSweet>();
                sweets[x, 0].Init(x, -1, this, SweetsType.NORMAL);
                sweets[x, 0].MovedComponent.Move(x, 0, fillTime);
                sweets[x, 0].ColoredComponent.SetColor((ColorSweet.ColorType)Random.Range(0, sweets[x, 0].ColoredComponent.NumColors));
                filledNotFinished = true;
            }
        }

        return(filledNotFinished);
    }
Esempio n. 18
0
    /// <summary>
    /// 分步填充
    /// </summary>
    public bool Fill()
    {
        bool filledNotFinished = false;                      //判断本次否填,是否完成

        for (int y = yHang - 2; y >= 0; y--)                 //从下往上
        {
            for (int x = 0; x < xLie; x++)                   //从左到右
            {
                GameSweet sweet = sweets[x, y];              //得到当前元素位置的物品对象
                if (sweet.CanMove())                         //如果能移动就填充
                {
                    GameSweet sweetBelow = sweets[x, y + 1]; //下边元素位置
                    if (sweetBelow.Type == SweetsType.EMPTY) //如果下方是空格子,就垂直向下填充
                    {
                        Destroy(sweetBelow.gameObject);
                        sweet.MovedComponet.Move(x, y + 1, fillTime);                         //上边的元素,往下移动
                        sweets[x, y + 1] = sweet;                                             //二维数组,对应位置更新。
                        CreateNewSweet(x, y, SweetsType.EMPTY);
                        filledNotFinished = true;
                    }
                    else                     //斜着填充
                    {
                        for (int down = -1; down < 1; down++)
                        {
                            if (down != 0)                             //不是正下方
                            {
                                int downX = x + down;
                                if (downX >= 0 && downX < xLie)                                 //规定范围,排除边缘情况
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];                 //左下方甜品
                                    if (downSweet.Type == SweetsType.EMPTY)                     //左下方为空
                                    {
                                        bool canfill = true;                                    //用来判断是否可以垂直填充
                                        for (int upY = y; upY >= 0; upY--)
                                        {
                                            GameSweet upSweet = sweets[downX, upY];                                             //正上方元素
                                            if (upSweet.CanMove())
                                            {
                                                break;                                                 //能移动直接跳出
                                            }
                                            else if (!upSweet.CanMove() && upSweet.Type != SweetsType.EMPTY)
                                            {
                                                canfill = false;
                                                break;
                                            }
                                        }

                                        if (!canfill)                                         //不能垂直填充
                                        {
                                            Destroy(downSweet.gameObject);                    //删除下边游戏的物体
                                            sweet.MovedComponet.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetsType.EMPTY);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        //最上排的特殊情况
        for (int x = 0; x < xLie; x++)
        {
            GameSweet sweet = sweets[x, 0];
            if (sweet.Type == SweetsType.EMPTY)
            {
                GameObject newSweet =
                    (GameObject)Instantiate(sweetPrefabDict[SweetsType.NORMAL], CorrectPosition(x, -1), Quaternion.identity);
                newSweet.transform.parent = transform;
                sweets[x, 0] = newSweet.GetComponent <GameSweet>();
                sweets[x, 0].Init(x, -1, this, SweetsType.NORMAL);
                sweets[x, 0].MovedComponet.Move(x, 0, fillTime);
                sweets[x, 0].ColorComponet.SetColor((ColorSweet.ColorType)Random.Range(0, sweets[x, 0].ColorComponet.NumColors));
                filledNotFinished = true;
            }
        }

        return(filledNotFinished);
    }
Esempio n. 19
0
    public bool Fill()
    {
        bool filledNotFinshed = false;

        for (int i = 0; i < xColumns; i++)  //最顶层单独填充因此排除,填充方向为Y。
        {
            for (int j = yRows - 2; j >= 0; j--)
            {
                GameSweet sweet = sweetsarray[j, i];

                if (sweet.CanMove())
                {
                    //  print(j + "," + i + 1);
                    GameSweet sweetfill = sweetsarray[j + 1, i]; //由于排列时 从顶到底  j+1为下一层 而不是上一层
                    if (sweetfill.Type == SweetsType.EMPTY)      //垂直填充,下方为空块
                    {
                        Destroy(sweetfill.gameObject);
                        sweet.MoveComponent.Move(i, j + 1, fillTime);
                        sweetsarray[j + 1, i] = sweet;
                        CreateSweet(i, j, SweetsType.EMPTY);
                        filledNotFinshed = true;
                        //  print("基本填充" + i + "," + j);
                    }
                    else //下方有障碍时 填充方法 为斜下 左或右
                    {
                        for (int down = -1; down <= 1; down++)//优先斜左下方滑动
                        {
                            if (down != 0)
                            {
                                int downx = i + down;
                                if (downx >= 0 && downx < xColumns)
                                {
                                    GameSweet downSweet = sweetsarray[j + 1, downx];
                                    if (downSweet.Type == SweetsType.EMPTY)
                                    {
                                        bool canfill = true;
                                        for (int moveY = j; moveY >= 0; moveY--)
                                        {
                                            GameSweet sweetmoveY = sweetsarray[moveY, downx];
                                            if (sweetmoveY.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetmoveY.CanMove() && sweetmoveY.Type != SweetsType.EMPTY)//斜向填充条件
                                            {
                                                canfill = false;
                                                break;
                                            }
                                        }
                                        if (!canfill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MoveComponent.Move(downx, j + 1, fillTime);
                                            sweetsarray[j + 1, downx] = sweet;
                                            CreateSweet(i, j, SweetsType.EMPTY);
                                            filledNotFinshed = true;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        for (int i = 0; i < xColumns; i++)//最顶层
        {
            GameSweet sweet = sweetsarray[0, i];
            if (sweet.Type == SweetsType.EMPTY)//生成sweet
            {
                GameSweet go = Instantiate(sweetPrefabDict[SweetsType.NORMAL], CorrectPosition(i, -1), Quaternion.identity);
                go.transform.SetParent(transform);
                sweetsarray[0, i] = go.GetComponent <GameSweet>();
                sweetsarray[0, i].Init(i, -1, Instance, SweetsType.NORMAL);
                sweetsarray[0, i].MoveComponent.Move(i, 0, fillTime);
                sweetsarray[0, i].ColorComponent.SetColor((ColorSweet.ColorEnum)(Random.Range(0, sweetsarray[0, i].ColorComponent.NumColors)));
                filledNotFinshed = true;
                // print("顶层填充" + i + "," + yRows + ",," + xColumns);
            }
        }

        return(filledNotFinshed);
    }
Esempio n. 20
0
    /// <summary>
    /// 清除匹配的方法
    /// </summary>
    #region
    //匹配方法
    public List <GameSweet> MatchSweets(GameSweet sweet, int newX, int newY)
    {
        if (sweet.CanMove())
        {
            ColorSweet.ColorType color                  = sweet.ColoredComponent.Color;
            List <GameSweet>     matchRowSweets         = new List <GameSweet>();
            List <GameSweet>     matchLineSweets        = new List <GameSweet>();
            List <GameSweet>     finishedMatchingSweets = new List <GameSweet>();

            //行匹配
            //当x=0代表向左,1代表向右遍历sweet所在的行的物体
            matchRowSweets.Add(sweet);
            for (int i = 0; i <= 1; i++)
            {
                for (int xDistance = 1; xDistance < xColum; xDistance++)
                {
                    int x;
                    if (i == 0)
                    {
                        x = newX - xDistance;
                    }
                    else
                    {
                        x = newX + xDistance;
                    }
                    if (x < 0 || x >= xColum)
                    {
                        break;
                    }
                    if (sweets[x, newY].CanColor() && sweets[x, newY].ColoredComponent.Color == color)
                    {
                        matchRowSweets.Add(sweets[x, newY]);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            if (matchRowSweets.Count >= 3)
            {
                for (int i = 0; i < matchRowSweets.Count; i++)
                {
                    finishedMatchingSweets.Add(matchRowSweets[i]);
                }
            }

            //L T型匹配
            //检查一下当前行遍历列表中的元素数量是否大于3
            if (matchRowSweets.Count >= 3)
            {
                for (int i = 0; i < matchRowSweets.Count; i++)
                {
                    //行匹配列表中满足匹配条件的每个元素上下依次进行列遍历
                    // 0代表上方 1代表下方
                    for (int j = 0; j <= 1; j++)
                    {
                        for (int yDistance = 1; yDistance < yRow; yDistance++)
                        {
                            int y;
                            if (j == 0)
                            {
                                y = newY - yDistance;
                            }
                            else
                            {
                                y = newY + yDistance;
                            }
                            if (y < 0 || y >= yRow)
                            {
                                break;
                            }

                            if (sweets[matchRowSweets[i].X, y].CanColor() && sweets[matchRowSweets[i].X, y].ColoredComponent.Color == color)
                            {
                                matchLineSweets.Add(sweets[matchRowSweets[i].X, y]);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }

                    if (matchLineSweets.Count < 2)
                    {
                        matchLineSweets.Clear();
                    }
                    else
                    {
                        for (int j = 0; j < matchLineSweets.Count; j++)
                        {
                            finishedMatchingSweets.Add(matchLineSweets[j]);
                        }
                        break;
                    }
                }
            }

            if (finishedMatchingSweets.Count >= 3)
            {
                return(finishedMatchingSweets);
            }
            matchRowSweets.Clear();
            matchLineSweets.Clear();

            matchLineSweets.Add(sweet);
            //列匹配

            //i=0代表往左,i=1代表往右
            for (int i = 0; i <= 1; i++)
            {
                for (int yDistance = 1; yDistance < yRow; yDistance++)
                {
                    int y;
                    if (i == 0)
                    {
                        y = newY - yDistance;
                    }
                    else
                    {
                        y = newY + yDistance;
                    }
                    if (y < 0 || y >= yRow)
                    {
                        break;
                    }

                    if (sweets[newX, y].CanColor() && sweets[newX, y].ColoredComponent.Color == color)
                    {
                        matchLineSweets.Add(sweets[newX, y]);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            if (matchLineSweets.Count >= 3)
            {
                for (int i = 0; i < matchLineSweets.Count; i++)
                {
                    finishedMatchingSweets.Add(matchLineSweets[i]);
                }
            }


            //L T型匹配
            //检查一下当前行遍历列表中的元素数量是否大于3
            if (matchLineSweets.Count >= 3)
            {
                for (int i = 0; i < matchLineSweets.Count; i++)
                {
                    //行匹配列表中满足匹配条件的每个元素上下依次进行列遍历
                    // 0代表上方 1代表下方
                    for (int j = 0; j <= 1; j++)
                    {
                        for (int xDistance = 1; xDistance < xColum; xDistance++)
                        {
                            int x;
                            if (j == 0)
                            {
                                x = newY - xDistance;
                            }
                            else
                            {
                                x = newY + xDistance;
                            }
                            if (x < 0 || x >= xColum)
                            {
                                break;
                            }

                            if (sweets[x, matchLineSweets[i].Y].CanColor() && sweets[x, matchLineSweets[i].Y].ColoredComponent.Color == color)
                            {
                                matchRowSweets.Add(sweets[x, matchLineSweets[i].Y]);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }

                    if (matchRowSweets.Count < 2)
                    {
                        matchRowSweets.Clear();
                    }
                    else
                    {
                        for (int j = 0; j < matchRowSweets.Count; j++)
                        {
                            finishedMatchingSweets.Add(matchRowSweets[j]);
                        }
                        break;
                    }
                }
            }


            if (finishedMatchingSweets.Count >= 3)
            {
                return(finishedMatchingSweets);
            }
        }
        Debug.Log("没有可以匹配的糖果");
        return(null);
    }
Esempio n. 21
0
    public bool Fill()
    {
        bool filledNotFinished = false;

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColumn; x++)
            {
                GameSweet sweet = sweets[x, y]; //得到当前原始的位置
                if (sweet.CanMove())            //如果可以移动
                {
                    GameSweet sweetBelow = sweets[x, y + 1];
                    if (sweetBelow.Type == SweetsType.EMPTY)
                    {
                        sweet.MoveComponent.Move(x, y + 1, fileTime);
                        sweets[x, y + 1] = sweet;
                        CreateNewSweet(x, y, SweetsType.EMPTY);
                        filledNotFinished = true;
                    }
                    else
                    {
                        //-1是左边,1是右边
                        for (int down = -1; down <= 1; down++)
                        {
                            if (down != 0)
                            {
                                int downX = x + down;
                                //如果不是最左边或者最后边
                                if (downX >= 0 && downX < xColumn)
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];
                                    //如果为空
                                    if (downSweet.Type == SweetsType.EMPTY)
                                    {
                                        bool canfill = true; //用来判断垂直填充是否可以满足填充需求
                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];
                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetsType.EMPTY)
                                            {
                                                canfill = false;
                                                break;
                                            }
                                        }
                                        if (!canfill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MoveComponent.Move(downX, y + 1, fileTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetsType.EMPTY);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        //最上排特殊情况,生成一行糖块
        for (int x = 0; x < xColumn; x++)
        {
            GameSweet sweet = sweets[x, 0];     //获取当前糖块
            if (sweet.Type == SweetsType.EMPTY) //如果当前位置糖块为空
            {
                //创建一块糖块,设置糖块的位置为-1行
                GameObject newSweet =
                    Instantiate(sweetPrefabDict[SweetsType.NORMAL], CorrectPositon(x, -1), Quaternion.identity);
                //设置糖块的父物体
                newSweet.transform.parent = sweetsTransform;

                sweets[x, 0] = newSweet.GetComponent <GameSweet>();
                sweets[x, 0].Init(x, -1, this, SweetsType.NORMAL);
                sweets[x, 0].MoveComponent.Move(x, 0, fileTime);
                sweets[x, 0].ColoredComponent
                .SetColor((ColorSweet.ColorType)Random.Range(0, sweets[x, 0].ColoredComponent.NumColors));
                filledNotFinished = true;
            }
        }
        return(filledNotFinished);
    }
Esempio n. 22
0
    /// <summary>
    /// 分步填充
    /// </summary>
    public bool Fill()
    {
        bool filledNotFinish = false;//是否填充完成

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColumn; x++)
            {
                GameSweet sweet = sweets[x, y];
                if (sweet.CanMove())//如果可以移动,则可以向下继续填充
                {
                    GameSweet sweetBelow = sweets[x, y + 1];
                    if (sweetBelow.Type == SweetType.EMPTY)//如果当前甜品下方为空甜品,则优先垂直填充
                    {
                        Destroy(sweetBelow.gameObject);
                        sweet.MoveSweetComponent.Move(x, y + 1, fillTime);
                        sweets[x, y + 1] = sweet;
                        CreatNewSweet(x, y, SweetType.EMPTY);
                        filledNotFinish = true;
                    }
                    else//斜向填充
                    {
                        for (int down = -1; down <= 1; down++)//-1代表左下方,1代表右下方
                        {
                            if (down != 0)
                            {
                                int downX = x + down;
                                if (downX >= 0 && downX < xColumn)               //排除边界
                                {
                                    GameSweet bevelSweet = sweets[downX, y + 1]; //斜方向的甜品
                                    if (bevelSweet.Type == SweetType.EMPTY)      //如果该甜品斜下方向为空甜品
                                    {
                                        bool canBevelFill = true;                //用来表示是否可以斜向填充
                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet bevelAboveSweet = sweets[downX, aboveY];//斜下方甜品的正上方的甜品
                                            if (bevelAboveSweet.Type != SweetType.EMPTY && !bevelAboveSweet.CanMove())
                                            {
                                                //如果不能移动且不为空,则可以进行斜向填充
                                                canBevelFill = false;
                                                break;
                                            }
                                            else if (bevelAboveSweet.CanMove())
                                            {
                                                //不做处理
                                                break;
                                            }
                                        }
                                        if (canBevelFill == false)
                                        {
                                            Destroy(bevelSweet.gameObject);
                                            sweets[x, y].MoveSweetComponent.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreatNewSweet(x, y, SweetType.EMPTY);
                                            filledNotFinish = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        //最上面一排特殊情况
        for (int x = 0; x < xColumn; x++)
        {
            GameSweet sweet = sweets[x, 0];
            if (sweet.Type == SweetType.EMPTY)//如果该甜品为空甜品,则进行实例化生成新的甜品
            {
                GameObject newSweet = Instantiate(sweetDict[SweetType.NORMAL], CorrectPosition(x, -1), Quaternion.identity);
                newSweet.transform.SetParent(spawner);
                sweets[x, 0] = newSweet.GetComponent <GameSweet>();
                sweets[x, 0].Init(x, -1, this, SweetType.NORMAL);
                sweets[x, 0].MoveSweetComponent.Move(x, 0, fillTime);
                sweets[x, 0].ColorSweetComponent.SetColor((ColorSweet.ColorType)Random.Range(0, sweets[x, 0].ColorSweetComponent.NumColor));
                Destroy(sweet.gameObject);

                filledNotFinish = true;
            }
        }
        return(filledNotFinish);
    }
Esempio n. 23
0
    private bool StepFill()
    {
        bool fillNotFinished = false;

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColumn; x++)
            {
                GameSweet sweet = sweets[x, y];
                if (sweet.CanMove())
                {
                    GameSweet belowSweet = sweets[x, y + 1];
                    if (belowSweet.Type == SweetsType.EMPTY)
                    {
                        Destroy(belowSweet.gameObject);
                        sweet.MovedCommpont.Move(x, y + 1, fillTime);
                        sweets[x, y + 1] = sweet;
                        CreateNewSweet(x, y, SweetsType.EMPTY);
                        fillNotFinished = true;
                    }
                    else
                    {
                        for (int down = -1; down <= 1; down++)
                        {
                            if (down != 0)
                            {
                                int downX = x + down;

                                if (downX >= 0 && downX < xColumn)
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];

                                    if (downSweet.Type == SweetsType.EMPTY)
                                    {
                                        bool canfill = true;//用来判断垂直填充是否可以满足填充要求

                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];
                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetsType.EMPTY)
                                            {
                                                canfill = false;
                                                break;
                                            }
                                        }

                                        if (!canfill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MovedCommpont.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetsType.EMPTY);
                                            fillNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        for (int x = 0; x < xColumn; x++)
        {
            GameSweet sweet = sweets[x, 0];
            if (sweet.Type == SweetsType.EMPTY)
            {
                GameObject obj = Instantiate(sweetPrefabDict[SweetsType.NORMAL], CorrectPosition(x, -1), Quaternion.identity);
                obj.transform.SetParent(transform);

                Destroy(sweets[x, 0].gameObject);
                sweets[x, 0] = obj.GetComponent <GameSweet>();
                sweets[x, 0].Init(x, -1, this, SweetsType.NORMAL);
                sweets[x, 0].MovedCommpont.Move(x, 0, fillTime);
                sweets[x, 0].ColorCommpont.SetColor((ColorSweet.ColorType)Random.Range(0, sweets[x, 0].ColorCommpont.NumColors));
                fillNotFinished = true;
            }
        }

        return(fillNotFinished);
    }
Esempio n. 24
0
    /// <summary>
    /// 判断是否能进行消除甜品
    /// </summary>
    /// <param name="sweet"></param>
    /// <param name="x"></param>
    /// <param name="y"></param>
    /// <returns></returns>
    public List <GameSweet> MatchSweets(GameSweet sweet, int newX, int newY)
    {
        if (sweet.CanMove() && sweet.CanColor())//如果当前甜品是能正常更换精灵的甜品(即不是空甜品或者不是障碍物等)
        {
            ColorSweet.ColorType color = sweet.ColorSweetComponent.Color;
            List <GameSweet>     matchRowSweetsList   = new List <GameSweet>(); //用来做横向匹配的链表
            List <GameSweet>     matchColumnSweetList = new List <GameSweet>(); // 用来做纵向匹配的链表
            List <GameSweet>     finishedMatchList    = new List <GameSweet>(); //匹配结束后的链表,同时返回该链表
            //行匹配
            matchRowSweetsList.Add(sweet);
            for (int i = 0; i <= 1; i++)//0代表往左匹配,1代表往右匹配
            {
                for (int xDistance = 1; xDistance < xColumn; xDistance++)
                {
                    int x;//和当前甜品要进行匹配的甜品的x坐标
                    if (i == 0)
                    {
                        x = newX - xDistance;
                    }
                    else
                    {
                        x = newX + xDistance;
                    }
                    if (x < 0 || x >= xColumn)//如果匹配完成则直接退出
                    {
                        break;
                    }
                    if (sweets[x, newY].CanColor() && color == sweets[x, newY].ColorSweetComponent.Color)//如果类型相同,则可以添加进链表
                    {
                        matchRowSweetsList.Add(sweets[x, newY]);
                    }
                    else
                    {
                        break;
                    }
                }
            }
            if (matchRowSweetsList.Count >= 3)
            {
                for (int m = 0; m < matchRowSweetsList.Count; m++)
                {
                    finishedMatchList.Add(matchRowSweetsList[m]);
                }
            }

            if (matchRowSweetsList.Count >= 3)
            {
                for (int i = 0; i < matchRowSweetsList.Count; i++)
                {
                    // finishedMatchList.Add(matchRowSweetsList[i]);
                    //行匹配完成后,再进行L,T型匹配,即对每一个二元素的列在进行匹配
                    for (int j = 0; j <= 1; j++)//j=0代表向上匹配,j=1代表向下匹配
                    {
                        for (int yDistance = 1; yDistance < yRow; yDistance++)
                        {
                            int y;
                            if (j == 0)
                            {
                                y = newY - yDistance;
                            }
                            else
                            {
                                y = newY + yDistance;
                            }
                            if (y < 0 || y >= yRow)
                            {
                                break;
                            }
                            if (sweets[matchRowSweetsList[i].X, y].CanColor() && sweets[matchRowSweetsList[i].X, y].ColorSweetComponent.Color == color)
                            {
                                matchColumnSweetList.Add(sweets[matchRowSweetsList[i].X, y]);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                    if (matchColumnSweetList.Count >= 2)//如果又在列方向找到两个或以上甜品,则添加到完成列表中
                    {
                        for (int k = 0; k < matchColumnSweetList.Count; k++)
                        {
                            finishedMatchList.Add(matchColumnSweetList[k]);
                        }
                        break;
                    }
                    else//否则进行清空
                    {
                        matchColumnSweetList.Clear();
                    }
                }
            }
            if (finishedMatchList.Count >= 3)
            {
                return(finishedMatchList);
            }
            matchRowSweetsList.Clear();
            matchColumnSweetList.Clear();
            // finishedMatchList.Clear();



            //清空后再进行列匹配
            //否则进行列匹配
            matchColumnSweetList.Add(sweet);
            for (int i = 0; i <= 1; i++)//0代表往上匹配,1代表往下匹配
            {
                for (int YDistance = 1; YDistance < yRow; YDistance++)
                {
                    int y;//和当前甜品要进行匹配的甜品的x坐标
                    if (i == 0)
                    {
                        y = newY - YDistance;
                    }
                    else
                    {
                        y = newY + YDistance;
                    }
                    if (y < 0 || y >= yRow)//如果匹配完成则直接退出
                    {
                        break;
                    }
                    if (sweets[newX, y].CanColor() && color == sweets[newX, y].ColorSweetComponent.Color)//如果类型相同,则可以添加进链表
                    {
                        matchColumnSweetList.Add(sweets[newX, y]);
                    }
                    else
                    {
                        break;
                    }
                }
            }
            if (matchColumnSweetList.Count >= 3)
            {
                for (int m = 0; m < matchColumnSweetList.Count; m++)
                {
                    finishedMatchList.Add(matchColumnSweetList[m]);
                }
            }

            if (matchColumnSweetList.Count >= 3)//列匹配完成后再进行L,T,型匹配,即再对每一个已经确定的甜品进行行遍历
            {
                for (int i = 0; i < matchColumnSweetList.Count; i++)
                {
                    //finishedMatchList.Add(matchColumnSweetList[i]);

                    for (int j = 0; j <= 1; j++)//j=0代表向左匹配,j=1代表向右匹配
                    {
                        for (int xDistance = 1; xDistance < xColumn; xDistance++)
                        {
                            int x;
                            if (j == 0)
                            {
                                x = newX - xDistance;
                            }
                            else
                            {
                                x = newX + xDistance;
                            }
                            if (x < 0 || x >= yRow)
                            {
                                break;
                            }
                            if (sweets[x, matchColumnSweetList[i].Y].CanColor() && sweets[x, matchColumnSweetList[i].Y].ColorSweetComponent.Color == color)
                            {
                                matchRowSweetsList.Add(sweets[x, matchColumnSweetList[i].Y]);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                    if (matchRowSweetsList.Count >= 2)//如果又在行方向找到两个或以上甜品,则添加到完成列表中
                    {
                        for (int k = 0; k < matchRowSweetsList.Count; k++)
                        {
                            finishedMatchList.Add(matchRowSweetsList[k]);
                        }
                        break;
                    }
                    else//否则进行清空
                    {
                        matchRowSweetsList.Clear();
                    }
                }
            }
            if (finishedMatchList.Count >= 3)
            {
                return(finishedMatchList);
            }
        }
        return(null);
    }
Esempio n. 25
0
    /// <summary>
    /// 分部填充
    /// </summary>
    /// <returns></returns>
    public bool Fill()
    {
        bool filledNotFinished = false;//判断本次填充是否完成

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColumn; x++)
            {
                GameSweet sweet = sweets[x, y]; //得到当前元素位置的甜品对象
                if (sweet.CanMove())            //如果无法移动,则无法往下填充
                {
                    GameSweet sweetBelow = sweets[x, y + 1];

                    if (sweetBelow.Type == SweetsType.EMPTY) //垂直填充
                    {
                        Destroy(sweetBelow.gameObject);
                        sweet.MovedComponent.Move(x, y + 1, fillTime);
                        sweets[x, y + 1] = sweet;
                        CreatNewSweet(x, y, SweetsType.EMPTY);
                        filledNotFinished = true;
                    }
                    else                                     //斜向填充
                    {
                        for (int down = -1; down <= 1; down++)
                        {
                            if (down != 0)                                      //排除0正下
                            {
                                int downX = x + down;                           //当前x坐标,-1 左下,0正下,1右下
                                if (downX >= 0 && downX < xColumn)              //排除边界情况
                                {
                                    GameSweet downSweet = sweets[downX, y + 1]; //先从左下方查看
                                    if (downSweet.Type == SweetsType.EMPTY)
                                    {
                                        bool canfill = true; //判断垂直填充是否能满足填充需求
                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];
                                            if (sweetAbove.CanMove())//上方元素可以移动,用上方元素进行垂直填充即可
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetsType.EMPTY)//上方元素不能移动,并且上方元素不是空,无法垂直填充,使用斜向填充
                                            {
                                                canfill = false;
                                            }
                                        }

                                        if (!canfill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MovedComponent.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreatNewSweet(x, y, SweetsType.EMPTY);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        //最上排的特殊情况
        for (int x = 0; x < xColumn; x++)
        {
            GameSweet sweet = sweets[x, 0];
            if (sweet.Type == SweetsType.EMPTY)
            {
                GameObject newSweet = Instantiate(sweetPrefabDict[SweetsType.NORMAL], CorrectPosition(x, 0), Quaternion.identity);
                newSweet.transform.SetParent(transform);

                sweets[x, 0] = newSweet.GetComponent <GameSweet>();
                sweets[x, 0].Init(x, -1, this, SweetsType.NORMAL);
                sweets[x, 0].MovedComponent.Move(x, 0, fillTime);
                sweets[x, 0].ColoredComponent.SetColor((ColorSweet.ColorType)Random.Range(0, sweets[x, 0].ColoredComponent.NumColors));
                filledNotFinished = true;
            }
        }

        return(filledNotFinished);
    }
Esempio n. 26
0
    /// <summary>
    /// 分步填充
    /// </summary>
    public bool Fill()
    {
        bool filledNotFinished = false;//判断本次填充是否完成

        for (int y = yRow - 2; y >= 0; y--)
        {
            for (int x = 0; x < xColumn; x++)
            {
                GameSweet sweet = sweets[x, y]; //得到当前元素位置tianpin

                if (sweet.CanMove())            //如果无法移动,则无法往下填充
                {
                    GameSweet sweetBelow = sweets[x, y + 1];

                    if (sweetBelow.Type == SweetType.EMPTY)
                    {
                        Destroy(sweetBelow.gameObject);
                        sweet.MovedComponent.Move(x, y + 1, fillTime);
                        sweets[x, y + 1] = sweet;
                        CreateNewSweet(x, y, SweetType.EMPTY);
                        filledNotFinished = true;
                    }
                    else   //斜向填充
                    {
                        for (int down = -1; down <= 1; down++)
                        {
                            if (down != 0)
                            {
                                int downX = x + down;

                                if (downX >= 0 && downX < xColumn)
                                {
                                    GameSweet downSweet = sweets[downX, y + 1];
                                    if (downSweet.Type == SweetType.EMPTY)
                                    {
                                        bool canfill = true;
                                        for (int aboveY = y; aboveY >= 0; aboveY--)
                                        {
                                            GameSweet sweetAbove = sweets[downX, aboveY];
                                            if (sweetAbove.CanMove())
                                            {
                                                break;
                                            }
                                            else if (!sweetAbove.CanMove() && sweetAbove.Type != SweetType.EMPTY)
                                            {
                                                canfill = false;
                                                break;
                                            }
                                        }

                                        if (!canfill)
                                        {
                                            Destroy(downSweet.gameObject);
                                            sweet.MovedComponent.Move(downX, y + 1, fillTime);
                                            sweets[downX, y + 1] = sweet;
                                            CreateNewSweet(x, y, SweetType.EMPTY);
                                            filledNotFinished = true;
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        //最上排特殊情况
        for (int x = 0; x < xColumn; x++)
        {
            GameSweet sweet = sweets[x, 0];

            if (sweet.Type == SweetType.EMPTY)
            {
                GameObject newSweet = Instantiate(sweetPrefabDic[SweetType.NORMAL], CorrectPosition(x, -1), Quaternion.identity) as GameObject;
                newSweet.transform.parent = transform;
                sweets[x, 0] = newSweet.GetComponent <GameSweet>();
                sweets[x, 0].Init(x, -1, this, SweetType.NORMAL);
                sweets[x, 0].MovedComponent.Move(x, 0, fillTime);
                sweets[x, 0].ColoredComponent.SetColor((ColorSweet.ColorType)(Random.Range(0, sweets[x, 0].ColoredComponent.NumColors)));
                filledNotFinished = true;
            }
        }

        return(filledNotFinished);
    }