使用C#重写网上的60行 Javascript 俄罗斯方块源码 (带注释)

在很久很久以前，就已经看过 60行Js的俄罗斯方块源码。无奈当时能力不够看明白，当时觉得就是个神作。

现在总算有空再看了，顺便用c#实现一遍（超过60行），顺道熟悉下Js API。

网上其他博客也有分析：教你看懂网上流传的60行JavaScript代码俄罗斯方块游戏   60行JS实现俄罗斯方块，这里就不再详述了，直接上代码。

Tetris.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace ConsoleTetris
{
    public class Block
    {
        public int x;   //本身 fk 已经记录了 方块所在的x坐标, 但是为了旋转时方便计算 所以新建一个x变量来记录坐标
        public int y;   //方块 fk 的y坐标
        public int s;   //记录方块旋转的index,方便旋转操作查找
        public int[] fk;//方块???
    }

    public class Tetris
    {
        
        //var map = eval("[" + Array(23).join("0x801,") + "0xfff]");
        // 1.Array(23) 创建一个23的数组
        // 2.array.join 返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator 字符串而生成的。
        // 3. 生成 ""+"0x801,"+""+"0x801,"+""+"0x801," ....           一共有22个 0x801
        // 4. 0x801 二进制: 100000000001
        // 5. 0xfff 二进制: 111111111111
        // 6. 最终生成字符串[0x801,0x801,0x801,...0x801,0xfff]
        // 7. 最终生成俄罗斯方块外墙的二维数组
        //  100000000001
        //  100000000001
        //  100000000001
        //  100000000001
        //  100000000001
        //  100000000001
        //  ...
        //  111111111111
        List<int> map;// = new int[23];
        int[][] tetris;
        public Dictionary<ConsoleKey, Action> keycom;


        int[] dia;
        Block pos;
        Block bak;
        Random r = new Random();

        public void init()
        {
            map = new List<int>(23);
            for (int i = 0; i < 22; ++i) map.Add(0x801);
            map.Add(0xfff);

            tetris = new int[7][];

            //□■■□
            //□■■□
            //□□□□
            //□□□□
            tetris[0] = new int[] { 0x6600 };

            //□□■□    □□□□
            //□□■□    ■■■■
            //□□■□    □□□□
            //□□■□    □□□□
            tetris[1] = new int[] {0x2222,0xf00};

            //■■□□    □□■□
            //□■■□    □■■□
            //□□□□    □■□□
            //□□□□    □□□□
            tetris[2] = new int[] {0xc600,0x2640};

            //□■■□    □■□□
            //■■□□    □■■□
            //□□□□    □□■□
            //□□□□    □□□□
            tetris[3] = new int[] {0x6c00,0x4620};

            //□■□□    □□□□    □■■□    □□□□
            //□■□□    □□■□    □□■□    □■■■
            //□■■□    ■■■□    □□■□    □■□□
            //□□□□    □□□□    □□□□    □□□□
            tetris[4] = new int[] {0x4460,0x2e0,0x6220,0x740};

            //□□■□    □□□□    □■■□    □□□□
            //□□■□    ■■■□    □■□□    □■□□
            //□■■□    □□■□    □■□□    □■■■
            //□□□□    □□□□    □□□□    □□□□
            tetris[5] = new int[] {0x2260,0xe20,0x6440,0x4700};

            //□□■□    □□□□    □□■□    □□■□
            //□■■□    □■■■    □□■■    □■■■
            //□□■□    □□■□    □□■□    □□□□
            //□□□□    □□□□    □□□□    □□□□
            tetris[6] = new int[] {0x2620,0x720,0x2320,0x2700};

            keycom = new Dictionary<ConsoleKey, Action>();
            keycom[ConsoleKey.UpArrow] = ()=>rotate(1);
            keycom[ConsoleKey.DownArrow] = down;
            keycom[ConsoleKey.LeftArrow] = ()=>move(2,1);
            keycom[ConsoleKey.RightArrow] = ()=>move(0.5f,-1);

        }


        public void start()
        {
            dia = tetris[r.Next(7)];
            bak = pos = new Block { y = 0, x = 4, s = r.Next(4) };
            rotate(0);
        }

        void over()
        {
            Console.WriteLine("GameOver");
            Thread.Sleep(1000);
            //Console.Read();
            Environment.Exit(0);
        }

        public void update(bool hit=false)
        {
            bak = new Block { fk = (int[])pos.fk.Clone(), y = pos.y, x = pos.x, s = pos.s }; //copy pos to bak
            if (hit) return;
            
            var buffer = new StringBuilder(map.Count * 12);
            for(var i=0;i<map.Count-1;++i)
            {
                var str = Convert.ToString(map[i], 2);
                str = str.Substring(1, str.Length - 2); //去掉头尾的墙 1
                buffer.Append('3'); //墙用3代替
                buffer.Append(str);
                buffer.Append('3'); //墙用3代替
                buffer.Append('
');
                
            }
            buffer.Append(Convert.ToString(map.Last(), 2).Replace('1', '3'));
            
            for(var i=0;i<4;++i)
            {
                var begin = (pos.y + i) * 13;// 一行12个方格(算上墙) + 1个换行符
                //var end = begin + 12;

                var str = Convert.ToString(pos.fk[i], 2);
                str = str.PadLeft(12, '0');
                for(var j=0;j<12;++j)
                {
                    if (str[j] == '1')
                        buffer[begin + j] = '2';
                }

            }
            
            buffer = buffer.Replace("0", "  ");
            buffer = buffer.Replace("1", "■");
            buffer = buffer.Replace("2", "□");
            buffer = buffer.Replace("3", "●");

            lock (this) //这里lock的原因是使用了多线程输出,防止输出缓存顺序错乱
            {
                Console.Clear();
                Console.WriteLine(buffer);
            }
        }

        bool Is()
        {
            for (var i = 0; i < 4 && pos.y + i < map.Count; ++i)
            {
                if ((pos.fk[i] & map[pos.y + i]) != 0) //已经发生碰撞(fk已经包含了位置信息,在 rotate函数内已经说明)
                {
                    pos = bak;
                    return true;
                }
            }
            return false;
        }

        void rotate(int r)
        {
            pos.s = (pos.s + r) % dia.Length;
            var f = dia[pos.s];
            if (pos.fk == null)
                pos.fk = new int[4];
            for (var i = 0; i < 4; ++i)
            {
                // 1. 将 f(32bit) 放到 fk[4]中
                // 例如 方块
                //  □■■□
                //  □■■□
                //  □□□□
                //  □□□□
                // 的 值为0x6600 -> 0110 0110 0000 0000
                // 然后分别将 每4个bit 分配到一个fk数组中
                // fk[0] = 0110
                // fk[1] = 0110
                // fk[2] = 0000
                // fk[3] = 0000
                // 2. 将 fk[4] 4*4的矩阵 扩展到 和map 同宽, 表示其在map中的位置(不是真正将数组设置到map中,模拟而已)
                // 如放到 2行 5列 (1开始算)
                //  100000000001
                //  100001100001
                //  100001100001
                //  100000000001
                //  100000000001
                //  ............
                //  111111111111

                pos.fk[i] = (f >> (12 - i * 4) & 15) << pos.x;
            }
            update(Is());
        }

        public void down()
        {
            ++pos.y;
            if (Is())
            {
                for (var i = 0; i < 4 && pos.y + i < 22; ++i) //循环fk数组 并且不是 map的底部
                {
                    if ((map[pos.y + i] |= pos.fk[i]) == 0xfff) //map中连墙体宽为12, 所以 0xfff的意思是 正行都已经满了
                    {
                        map.RemoveAt(pos.y + i);
                        map.Insert(0, 0x801);
                    }
                }

                if (map[1] != 0x801) //顶头第二行已经满
                {
                    over();
                }

                start();

            }
            update(false);
        }

        void move(float t, int k)
        {
            //t 为 2 或者0.5f, 可以看作是移位 x<<1 或 x>>1
            //x << -1 永远为0,否则 如果可以看作是 x>>1 就好了

            pos.x += k;
            for (var i = 0; i < 4; ++i)
            {
                pos.fk[i] = (int)(pos.fk[i] * t);
            }
            update(Is());
        }
    }
}

Program.cs

using System;
using System.Threading;

namespace ConsoleTetris
{
    class Program
    {
        static void Main(string[] args)
        {
            var tetris = new Tetris();
            var thread = new Thread(() => ReadKey(tetris));

            tetris.init();
            tetris.start();
            thread.Start();

            while (true)
            {
                tetris.down();
                Thread.Sleep(400);
            }
            
        }

        static void ReadKey(Tetris t)
        {
            while(true)
            {
                var key = Console.ReadKey().Key;
                Action a = null;
                if (t.keycom.TryGetValue(key, out a))
                {
                    a();
                }
                Thread.Sleep(3);
            }
        }
    }

}

以下是原JS代码：

<!doctype html><html><head></head><body>
<div id="box" style="252px;font:25px/25px 宋体;background:#000;color:#9f9;border:#999 20px ridge;text-shadow:2px 3px 1px #0f0;"></div>
<script>
var map=eval("["+Array(23).join("0x801,")+"0xfff]");
var tatris=[[0x6600],[0x2222,0xf00],[0xc600,0x2640],[0x6c00,0x4620],[0x4460,0x2e0,0x6220,0x740],[0x2260,0xe20,0x6440,0x4700],[0x2620,0x720,0x2320,0x2700]];
var keycom={"38":"rotate(1)","40":"down()","37":"move(2,1)","39":"move(0.5,-1)"};
var dia, pos, bak, run;
function start(){
    dia=tatris[~~(Math.random()*7)];
    bak=pos={fk:[],y:0,x:4,s:~~(Math.random()*4)};
    rotate(0);
}
function over(){
    document.onkeydown=null;
    clearInterval(run);
    alert("GAME OVER");
}
function update(t){
    bak={fk:pos.fk.slice(0),y:pos.y,x:pos.x,s:pos.s};
    if(t) return;
    for(var i=0,a2=""; i<22; i++)
        a2+=map[i].toString(2).slice(1,-1)+"<br/>";
    for(var i=0,n; i<4; i++)
        if(/([^0]+)/.test(bak.fk[i].toString(2).replace(/1/g,"u25a1")))
            a2=a2.substr(0,n=(bak.y+i+1)*15-RegExp.$_.length-4)+RegExp.$1+a2.slice(n+RegExp.$1.length);
    document.getElementById("box").innerHTML=a2.replace(/1/g,"u25a0").replace(/0/g,"u3000");
}
function is(){
    for(var i=0; i<4; i++)
        if((pos.fk[i]&map[pos.y+i])!=0) return pos=bak;
}
function rotate(r){
    var f=dia[pos.s=(pos.s+r)%dia.length];
    for(var i=0; i<4; i++)
        pos.fk[i]=(f>>(12-i*4)&15)<<pos.x;
    update(is());
}
function down(){
    ++pos.y;
    if(is()){
        for(var i=0; i<4 && pos.y+i<22; i++)
            if((map[pos.y+i]|=pos.fk[i])==0xfff)
                map.splice(pos.y+i,1), map.unshift(0x801);
        if(map[1]!=0x801) return over();
        start();
    }
    update();
}
function move(t,k){
    pos.x+=k;
    for(var i=0; i<4; i++)
        pos.fk[i]*=t;
    update(is());
}
document.onkeydown=function(e){
    eval(keycom[(e?e:event).keyCode]);
};
start();
run=setInterval("down()",400);
</script></body></html>

下面是注释版：

<!doctype html>  
<html>
    <head>
        <title>俄罗斯方块</title>
    </head>
    
    <body>  
        <div id = "box"
             style = "margin : 20px auto;
                      text-align : center;
                      width : 252px;
                      font : 25px / 25px 宋体;
                      background : #000;
                      color : #9f9;
                      border : #999 20px ridge;
                      text-shadow : 2px 3px 1px #0f0;">
        </div>
        
        <script>  
            //eval的功能是把字符串变成实际运行时的JavaScript代码
            //这里代码变换之后相当于 var map = [0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0x801, 0xfff];
            //其二进制形式如下
            //100000000001 十六进制对照 0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801            
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //100000000001              0x801
            //111111111111              0xfff
            //数据呈U形分布，没错，这就是俄罗斯方块的地图（或者游戏场地更为合适？）的存储区
            var map = eval("[" + Array(23).join("0x801,") + "0xfff]"); 
            
            //这个锯齿数组存储的是7种俄罗斯方块的图案信息
            //俄罗斯方块在不同的旋转角度下会产生不同的图案，当然可以通过算法实现旋转图案生成，这里为了减少代码复杂性直接给出了不同旋转状态下的图案数据
            //很明显，第一个0x6600就是7种俄罗斯方块之中的正方形方块
            //0x6600二进制分四行表示如下
            //0110
            //0110
            //0000
            //0000
            //这就是正方形图案的表示，可以看出，这里统一采用一个16位数来存储4 * 4的俄罗斯方块图案
            //因为正方形图案旋转不会有形状的改变，所以此行只存储了一个图案数据
            var tatris = [[0x6600],
                          [0x2222, 0x0f00],
                          [0xc600, 0x2640],
                          [0x6c00, 0x4620],
                          [0x4460, 0x2e0, 0x6220, 0x740],
                          [0x2260, 0x0e20, 0x6440, 0x4700], 
                          [0x2620, 0x720, 0x2320, 0x2700]];  

            //此对象之中存储的是按键键值（上，下，左，右）和函数之间的调用映射关系，之后通过eval可以做好调用映射
            var keycom = {"38" : "rotate(1)",
                          "40" : "down()",
                          "37" : "move(2, 1)",
                          "39" : "move(0.5, -1)"};
            
            //dia存储选取的俄罗斯方块类型（一共七种俄罗斯方块类型）
            //pos是前台正在下落的俄罗斯方块图案（每一种俄罗斯方块类型有属于自己的图案，如果不清楚可以查看上文的锯齿数组）对象
            //bak里存储关于pos图案对象的备份，在需要的时候可以实现对于pos运动的撤销
            var dia, pos, bak, run;
            
            //在游戏场景上方产生一个新的俄罗斯方块
            function start(){ 
            
                //产生0~6的随机数，~运算符在JavaScript依然是位取反运算，隐式实现了浮点数到整形的转换，这是一个很丑陋的取整实现方式
                //其作用是在七种基本俄罗斯方块类型之中随机选择一个
                dia = tatris[~~(Math.random() * 7)];
                
                //pos和bak两个对象分别为前后台，实现俄罗斯方块运动的备份和撤销
                bak = pos = {fk : [],                                    //这是一个数组存储的是图案转化之后的二进制数据
                             y : 0,                                        //初生俄罗斯方块的y坐标 
                             x : 4,                                     //初生俄罗斯方块的x坐标，相对于右侧
                             s : ~~(Math.random() * dia.length)};        //在特定的俄罗斯方块类型之中随机选择一个具体的图案
                
                //新生的俄罗斯方块不旋转，所以这里参数为0
                rotate(0);
            } 
            
            //旋转，实际上这里做的处理只不过是旋转旋转之后的俄罗斯方块具体图案，之后进行移位，根据X坐标把位置移动到场景里对应的地点
            function rotate(r){ 
            
                //这里是根据旋转参数 r 选择具体的俄罗斯方块图案，这里的 f ，就是上文之中的十六进制数
                //这里把当前pos.s的值和r（也就是旋转角度）相加，最后和dia.length求余，实现了旋转循环
                var f = dia[pos.s = (pos.s + r) % dia.length];
                
                //根据f（也就是上文之中提供的 16 位数据）每4位一行填写到fk数组之中
                for(var i = 0; i < 4; i++) {
                    
                    //初生的俄罗斯方块pos.x的值为4，因为是4 * 4的团所以在宽度为12的场景里左移4位之后就位于中间四列范围内
                    pos.fk[i] = (f >> (12 - i * 4) & 0x000f) << pos.x;
                }
                
                //更新场景
                update(is());  
            }      

            //这是什么意思，这是一个判断，判断有没有重叠
            function is(){  
            
                //对于当前俄罗斯方块图案进行逐行分析
                for(var i = 0; i < 4; i++) {
                
                    //把俄罗斯方块图案每一行的二进制位与场景内的二进制位进行位与，如果结果非0的话，那么这就证明图案和场景之中的实体（比如墙或者是已经落底的俄罗斯方块）重合了
                    //既然重合了，那么之前的运动就是非法的，所以在这个if语句里面调用之前备份的bak实现对于pos的恢复
                    if((pos.fk[i] & map[pos.y + i]) != 0) {
                        
                        return pos = bak;
                    }                            
                }    

                //如果没有重合，那么这里默认返回空
            }      
            
            //此函数产生用于绘制场景的字符串并且写入到div之中完成游戏场景的更新
            function update(t){  
            
                //把pos备份到bak之中，slice(0)意为从0号开始到结束的数组，也就是全数组，这里不能直接赋值，否则只是建立引用关系，起不到数据备份的效果
                bak = {fk : pos.fk.slice(0), y : pos.y, x : pos.x, s : pos.s};  
                
                //如果俄罗斯方块和场景实体重合了的话，就直接return返回，不需要重绘场景
                if (t) {
                
                    return;
                }
                
                //这里是根据map进行转换，转化得到的是01加上换行的原始串
                for(var i = 0, a2 = ""; i < 22; i++) {
                
                    //br就是换行，在这个循环里，把地图之中所有数据以二进制数字的形式写入a2字符串
                    //这里2是参数，指定基底，2的话就是返回二进制串的形式
                    //slice(1, -1)这里的参数1，-1作用是取除了墙（收尾位）之外中间场景数据（10位）
                    a2 += map[i].toString(2).slice(1, -1) + "<br/>";
                }
                
                //这里实现的是对于字符串的替换处理，就是把原始的01字符串转换成为方块汉字串
                for(var i = 0, n; i < 4; i++) {
                
                    //这个循环处理的是正在下落的俄罗斯方块的绘制
                    ////u25a1是空格方块，这里也是隐式使用正则表达式
                    if(/([^0]+)/.test(bak.fk[i].toString(2).replace(/1/g, "u25a1"))) { 
                    
                        a2 = a2.substr(0, n = (bak.y + i + 1) * 15 - RegExp.$_.length - 4) + RegExp.$1 + a2.slice(n + RegExp.$1.length);
                    }
                }
                
                //对于a2字符串进行替换，并且显示在div之中，这里是应用
                ////u25a0是黑色方块 u3000是空，这里实现的是替换div之中的文本，由数字替换成为两种方块或者空白
                document.getElementById("box").innerHTML = a2.replace(/1/g, "u25a0").replace(/0/g, "u3000");
            }  
        
            //游戏结束
            function over(){  
            
                //撤销onkeydown的事件关联
                document.onkeydown = null;
                
                //清理之前设置的俄罗斯方块下落定时器
                clearInterval(run);
                
                //弹出游戏结束对话框
                alert("游戏结束");  
            }  

            //俄罗斯方块下落
            function down(){ 
            
                //pos就是当前的（前台）俄罗斯方块，这里y坐标++，就相当于下落
                ++pos.y; 
                
                //如果俄罗斯方块和场景实体重合了的话
                if(is()){ 
                
                    //这里的作用是消行
                    for(var i = 0; i < 4 && pos.y + i < 22; i++) { 
                    
                        //和实体场景进行位或并且赋值，如果最后赋值结果为0xfff，也就说明当前行被完全填充了，可以消行
                        if((map[pos.y + i] |= pos.fk[i]) == 0xfff) {
                        
                            //行删除
                            map.splice(pos.y + i, 1);
                            //首行添加，unshift的作用是在数组第0号元素之前添加新元素，新的元素作为数组首元素
                            map.unshift(0x801);
                        }
                    }                                
                    
                    //如果最上面一行不是空了，俄罗斯方块垒满了，则游戏结束
                    if(map[1] != 0x801) {
                        
                        return over();
                    }
                    
                    //这里重新产生下一个俄罗斯方块
                    start();  
                } 
                
                //否则的话更新，因为这里不是局部更新，是全局更新，所以重新绘制一下map就可以了
                update();  
            }  

            //左右移动，t参数只能为2或者是0.5
            //这样实现左移右移（相当于移位运算）这种方法也很丑陋，但是为了简短只能这样了
            //这样做很丑陋，但是可以让代码简短一些
            function move(t, k){  
            
                pos.x += k;  
                
                for(var i = 0; i < 4; i++) { 
                    
                    //*=t在这里实现了左右移1位赋值的功能
                    pos.fk[i] *= t;  
                }
                
                //左右移之后的更新，这里同样进行了重合判断，如果和左右墙重合的话，那么一样会撤销操作并且不更新场景
                update(is());  
            }  

            //设置按键事件映射，这样按下键的时候就会触发对应的事件，具体来说就是触发对应的move，只有2和0.5
            document.onkeydown = function(e) {  
            
                //eval生成的JavaScript代码，在这里就被执行了
                eval(keycom[(e ? e : event).keyCode]);  
            };
              
            //这样看来的话，这几乎是一个递归。。。
            start();

            //设置俄罗斯方块下落定时器，500毫秒触发一次，调节这里的数字可以调整游戏之中俄罗斯方块下落的快慢
            run = setInterval("down()", 500);
        </script>
    </body>
</html>