对对碰方块交换及消去效果实现

为了学习C#绘图，前段时间下了个对对碰的原码看了下。发现原作者的代码中有些地方不够理想：没有方块的互换位置，方块消失这两个效果，操作起来显得很生硬。于是自己把整个代码重写了一遍，包括进度条。

方块的互换包括以下几步：

1.当用户按下左键时检测所选择的"起始方块"。

2.当用户松开左键时根据光标所在方向判断要交换的"目标方块"。

3.用Timer实现两个方块的位置交换效果，并完成相应后台数据位置的交换。

4.触发交换完成事件，让主界面刷新。

//交换两个方块的位置,把A交换到B
        public void changePosition()
        {
            if (isfinished)
            {
                isfinished = false;
                pfrom = new Point(bfrom.X, bfrom.Y);
                pto = new Point(bto.X, bto.Y);
                changeTimer.Start();                
            }
            
        }

为了防止用户点击过快导致交换的顺序混乱所以设置一个isfinished全局变量，只有上一个交换完成后下一对才可以开始。

生成一Timer，每次Tick时重绘两个方块的位置，在这之前要先行记录下两个方块的原位置，然后相互向对方的原位置移动。

changeTimer = new Timer();
            changeTimer.Interval = 5;
            changeTimer.Tick += new EventHandler(changeTimer_Tick);


 void changeTimer_Tick(object sender, EventArgs e)
        {
            doChange();
        }



 /// <summary>
        /// 交换位置
        /// </summary>
        private void doChange()
        {

            if (bfrom.YNum != bto.YNum)
            {
                if (bfrom.X != pto.X || bto.X != pfrom.X)
                {
                    if (Math.Abs(bfrom.X - pto.X) > 5 || Math.Abs(bto.X - pfrom.X) > 5)
                    {
                        if (Math.Abs(bfrom.X - pto.X) > 5)
                        {
                            bfrom.X = bfrom.X + (pto.X - pfrom.X) / 10;
                        }

                        if (Math.Abs(bto.X - pfrom.X) > 5)
                        {
                            bto.X = bto.X + (pfrom.X - pto.X) / 10;
                        }
                    }                    
                    else
                    {
                        bto.X = pfrom.X;
                        bfrom.X = pto.X;

                        //位置交换完成后再交换Matrix中的位置

                        Block bufblock = bfrom;
                        blockMatrix[bfrom.XNum,bfrom.YNum]=bto;
                        blockMatrix[bto.XNum, bto.YNum] = bufblock;

                        //再交换Block中的标记
                        int num = bfrom.YNum;
                        bfrom.YNum = bto.YNum;
                        bto.YNum = num;
                        drawAll();
                        changeTimer.Stop();                  
                        isfinished = true;
                        deletBlocks();
                    }

                    bto.drawBlock(workfield, BlockState.normal);
                    bfrom.drawBlock(workfield, BlockState.normal);
                    imgchanged();
                                        
                }


            }
            else
            {
                if (bfrom.Y != pto.Y || bto.Y != pfrom.Y)
                {

                    if (Math.Abs(bfrom.Y - pto.Y) > 5 || Math.Abs(bto.Y - pfrom.Y) > 5)
                    {
                        if (Math.Abs(bfrom.Y - pto.Y) > 5)
                        {
                            bfrom.Y = bfrom.Y + (pto.Y - pfrom.Y) / 10;
                        }
                        
                        if (Math.Abs(bto.Y - pfrom.Y) > 5)
                        {
                            bto.Y = bto.Y + (pfrom.Y - pto.Y) / 10;
                        }
                    }                    
                    else
                    {
                        bto.Y = pfrom.Y;
                        bfrom.Y = pto.Y;

                        Block bufblock = bfrom;
                        blockMatrix[bfrom.XNum, bfrom.YNum] = bto;
                        blockMatrix[bto.XNum, bto.YNum] = bufblock;

                        int num = bfrom.XNum;
                        bfrom.XNum = bto.XNum;
                        bto.XNum = num;
                        drawAll();
                        changeTimer.Stop();
                        isfinished = true;
                        deletBlocks();                        
                    }

                    bto.drawBlock(workfield, BlockState.normal);
                    bfrom.drawBlock(workfield, BlockState.normal);
                    imgchanged();
                }
            
            
            }                        

        }

代码中的deletBlocks();是用来消除方块的。

效果如下：

消去效果：

 /// <summary>
        /// 判断整个矩阵，将符合条件的方块加入消去队列，并实现消去效果
        /// </summary>
        public void deletBlocks()
        {
            delBlocks.Clear();
            collectCancelBlocks();
            shiningCount = 0;
            deleteTimer.Start();
        }

delBlocks为一个ArrayList,放置所有要消去的块。

/// <summary>
        /// 将符合条件的方块加入消去队列
        /// </summary>
        private void collectCancelBlocks()
        {
            for (int i = 0; i < 10; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    //十字型判断
                    bool dir1 = j-1>=0 ? blockMatrix[i, j].ImgType == blockMatrix[i, j - 1].ImgType : false;//左
                    bool dir2 = j+1<=9 ? blockMatrix[i, j].ImgType == blockMatrix[i, j + 1].ImgType : false;//右
                    bool dir3 = i-1>=0 ? blockMatrix[i, j].ImgType == blockMatrix[i-1, j].ImgType : false;//上
                    bool dir4 = i+1<=9 ? blockMatrix[i, j].ImgType == blockMatrix[i+1, j].ImgType : false;//下

                    //横
                    if (dir1 && dir2)
                    {
                        jugeAndAdd(i,j);
                        jugeAndAdd(i,j-1);
                        jugeAndAdd(i,j+1);
                    }

                    //竖
                    if(dir3&&dir4)
                    {
                        jugeAndAdd(i, j);
                        jugeAndAdd(i-1, j);
                        jugeAndAdd(i+1, j);
                    }

                    //上右
                    if(dir3&&dir2)
                    {
                        jugeAndAdd(i, j);
                        jugeAndAdd(i-1, j);
                        jugeAndAdd(i, j + 1);
                    }

                    //左下
                    if(dir1&&dir4)
                    {
                        jugeAndAdd(i, j);
                        jugeAndAdd(i, j - 1);
                        jugeAndAdd(i+1, j);
                    }

                    //右下
                    if(dir2&&dir4)
                    {
                        jugeAndAdd(i, j);
                        jugeAndAdd(i, j + 1);
                        jugeAndAdd(i+1, j);
                    }

                    //左上
                    if(dir1&&dir3)
                    {
                        jugeAndAdd(i, j);
                        jugeAndAdd(i, j - 1);
                        jugeAndAdd(i-1, j);
                    }                   
                  
                }
            }
        }

        /// <summary>
        /// 判断方块是否已加入消除队列，若否则加入。
        /// </summary>
        /// <param name="i"></param>
        /// <param name="j"></param>
        private void jugeAndAdd(int i,int j)
        {
            if (!delBlocks.Contains(blockMatrix[i, j]))
            {
                delBlocks.Add(blockMatrix[i, j]);
            }
        }

        /// <summary>
        /// 实现方块的消除效果
        /// </summary>
        private void deleteBlock()
        {
            //闪烁固定次数后将方块类型设置为none跳出。
            if (shiningCount > 6)
            {
                foreach (Block block in delBlocks)
                {
                    block.ImgType = BlocPic.none;
                }
                deleteTimer.Stop();
                reLoadMatrix();
                return;
            }
                
            if (shiningCount % 2 == 0)
            {
                foreach (Block block in delBlocks)
                {
                    block.drawBlock(workfield, BlockState.cancled);
                }
            }
            else
            {
                foreach (Block block in delBlocks)
                {
                    block.drawBlock(workfield, BlockState.normal);
                }
            }
            shiningCount++;
            imgchanged();
        }

再将消去的块的上方方块下移，并随机生成新的块放到最顶上。

/// <summary>
        /// 重新排列矩阵,将消失的方块上方的方块下移，并为最上层方块随机生成新的图片
        /// 从上往下扫描，遇到为none的则将其上面的图片交换下来。
        /// </summary>
        public void reLoadMatrix()
        {
            Random rand = new Random(DateTime.Now.Second);
            for (int i = 0; i < 10; i++)
            {
                for (int j = 0; j < 10; j++)
                {
                    if (blockMatrix[i, j].ImgType == BlocPic.none)
                    {
                        int level = i;
                        while (level >= 1)
                        {
                            blockMatrix[level, j].ImgType = blockMatrix[level - 1, j].ImgType;
                            level--;
                        }
                        blockMatrix[0, j].ImgType = (BlocPic)Enum.ToObject(typeof(BlocPic), rand.Next(1, 9));
                    }
                }
            }
            drawAll();
            imgchanged();
            deletBlocks();
            //viewMatrix();
            
        }

效果如下：