JS版俄罗斯方块第二版

最新推荐文章于 2022-12-29 08:58:54 发布
最新推荐文章于 2022-12-29 08:58:54 发布
阅读量1.3k 收藏 3
点赞数 1
分类专栏： JavaScript Demo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxb2008/article/details/17979993
版权

和第一版无差别，主要调整了下代码

 

 

<!DOCTYPE html>  
<html>  
<head>  
    <meta charset="UTF-8">  
    <title></title>  
</head>  
<body>  
  
  
</body>  
<script type="text/javascript">  
  
    (function () {  
  
        var Cell = {  
            status: [  
//------------------------------------------------------------------------------------------------  
            /****/  
//------------------------------------------------------------------------------------------------  
                [   //长条****  
                    [  
                        [0, 0, 0, 0],  
                        [1, 1, 1, 1],  
                        [0, 0, 0, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 1, 0, 0],  
                        [0, 1, 0, 0],  
                        [0, 1, 0, 0],  
                        [0, 1, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [1, 1, 1, 1],  
                        [0, 0, 0, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 1, 0, 0],  
                        [0, 1, 0, 0],  
                        [0, 1, 0, 0],  
                        [0, 1, 0, 0]  
                    ]  
                ] ,  
//------------------------------------------------------------------------------------------------  
                /* 
                 * 
                 * */  
//------------------------------------------------------------------------------------------------  
                [  
                    [  
                        [0, 0, 0, 0],  
                        [0, 2, 0, 0],  
                        [0, 2, 2, 2],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [0, 2, 2, 0],  
                        [0, 2, 0, 0],  
                        [0, 2, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [2, 2, 2, 0],  
                        [0, 0, 2, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 2, 0],  
                        [0, 0, 2, 0],  
                        [0, 2, 2, 0],  
                        [0, 0, 0, 0]  
                    ]  
                ] ,  
//------------------------------------------------------------------------------------------------  
                /* 
                 * 
                 * */  
//------------------------------------------------------------------------------------------------  
                [  
                    [  
                        [0, 0, 0, 0],  
                        [0, 3, 3, 3],  
                        [0, 3, 0, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 3, 3, 0],  
                        [0, 0, 3, 0],  
                        [0, 0, 3, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [0, 0, 3, 0],  
                        [3, 3, 3, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 3, 0, 0],  
                        [0, 3, 0, 0],  
                        [0, 3, 3, 0],  
                        [0, 0, 0, 0]  
                    ]  
                ] ,  
//------------------------------------------------------------------------------------------------  
                /* 
                 * * 
                 */  
//------------------------------------------------------------------------------------------------  
                [  
                    [  
                        [0, 4, 0, 0],  
                        [0, 4, 4, 0],  
                        [0, 0, 4, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [0, 4, 4, 0],  
                        [4, 4, 0, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 4, 0, 0],  
                        [0, 4, 4, 0],  
                        [0, 0, 4, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [0, 4, 4, 0],  
                        [4, 4, 0, 0],  
                        [0, 0, 0, 0]  
                    ]  
                ] ,  
//------------------------------------------------------------------------------------------------  
                /* 
                 * * 
                 */  
//------------------------------------------------------------------------------------------------  
                [  
                    [  
                        [0, 0, 5, 0],  
                        [0, 5, 5, 0],  
                        [0, 5, 0, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [5, 5, 0, 0],  
                        [0, 5, 5, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 5, 0],  
                        [0, 5, 5, 0],  
                        [0, 5, 0, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [5, 5, 0, 0],  
                        [0, 5, 5, 0],  
                        [0, 0, 0, 0]  
                    ]  
                ] ,  
  
//------------------------------------------------------------------------------------------------  
                /* 
                 * * */  
//------------------------------------------------------------------------------------------------  
                [  
                    [  
                        [0, 0, 0, 0],  
                        [0, 6, 0, 0],  
                        [6, 6, 6, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 6, 0, 0],  
                        [0, 6, 6, 0],  
                        [0, 6, 0, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [6, 6, 6, 0],  
                        [0, 6, 0, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 6, 0, 0],  
                        [6, 6, 0, 0],  
                        [0, 6, 0, 0],  
                        [0, 0, 0, 0]  
                    ]  
                ] ,  
  
//------------------------------------------------------------------------------------------------  
                /* 
                 * * */  
//------------------------------------------------------------------------------------------------  
                [  
                    [  
                        [0, 0, 0, 0],  
                        [0, 7, 7, 0],  
                        [0, 7, 7, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [0, 7, 7, 0],  
                        [0, 7, 7, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [0, 7, 7, 0],  
                        [0, 7, 7, 0],  
                        [0, 0, 0, 0]  
                    ],  
                    [  
                        [0, 0, 0, 0],  
                        [0, 7, 7, 0],  
                        [0, 7, 7, 0],  
                        [0, 0, 0, 0]  
                    ]  
                ]  
            ],  
            statusSum: 7,  
            color: ["", "red", "green", "blue", "yellow", "orange", "pink", "purple", "black"],  
            width: 10  
        };  
  
  
        function Box() {  
            return this._init();  
        };  
        Box.prototype = {  
            x: 0,  
            y: 0,  
            index: 0,  
            status: [],  
            divBox: null,  
            init:function(){  
                this.x = 5;  
                this.y = -4;  
            },  
            _init: function () {  
                this.init();  
                this._createBox();  
            },  
            _createBox: function () {  
                var statusIndex = Math.random() * Cell.statusSum;  
                this.status = Cell.status[parseInt(statusIndex) ];  
                this.divBox = this._createDivBox();  
            },  
            _createDivBox: function () {  
                var dbox = document.createElement("div");  
                dbox.style.position = "absolute";  
                var curMode = this.status[this.index];     //当前方块的形状  
                for (var y in  curMode) {  
                    for (var x in curMode[y]) {  
                        if (curMode[y][x] == 0) continue;  
                        var d = document.createElement("div");  
                        d.style.position = "absolute";  
                        d.style.top = y * Cell.width + "px";  
                        d.style.left = x * Cell.width + "px";  
                        d.style.width = Cell.width + "px";  
                        d.style.height = Cell.width + "px";  
                        d.style.overflow = "hidden";
                        d.style.backgroundColor = Cell.color[curMode[y][x]];
                        dbox.appendChild(d);  
                    }  
                }  
                return dbox;  
            },  
            _dropDivBox: function (_divBox) {  
                if (_divBox) {  
                    _divBox.parentNode.removeChild(_divBox);  
                }  
            },  
  
            _move: function (px, py) {  
                this.x = this.x + px;  
                this.y = this.y + py;  
            },  
  
            /*----------------------------------------------------------------------------------*/  
            drop: function () {  
                this._dropDivBox(this.divBox);  
            },  
  
            draw: function () {  
                this.divBox.style.left = this.x * Cell.width + "px";  
                this.divBox.style.top = this.y * Cell.width + "px";  
            },  
  
            move: function (x, y) {  
                this._move(x, y);  
                this.draw();  
            },  
            around: function () {  
                this.index++;  
                if (this.index >= 4) {  
                    this.index = 0;  
                }  
  
                var bak = this.divBox;  
                this.divBox = this._createDivBox();  
                this._dropDivBox(bak);  
            }  
  
            /*----------------------------------------------------------------------------------*/  
  
        };  
  
        /** 
         * 游戏画布 
         * @returns {*} 
         * @constructor 
         */  
        function Tetris() {  
            return this._init();  
        }  
  
        Tetris.prototype = {  
            LEFT: 37,  
            UP: 38,  
            RIGHT: 39,  
            DOWM: 40,  
  
            width: 15,  
            height: 20,  
  
            canvas:[],           //二维数组，0值=无阻碍  
            canvasDivBox:null, //大div,装载着canvasDivCell每一个小格的DIV。整体  
            canvasDivCell:[],  // 二维数组,每一个小格DIV  
            colorBlack: Cell.color.length - 1,  
            score: 0,  
            scoreDivBox:null,  
  
            time: 0,  
            delay: 250,
            isMove: false,  
  
            curBox:null,  
            nextBox:null,  
  
            _init: function () {  
                this._initCanvas();  
                this._createScoreDivBox();  
                this.start();  
            } ,  
            _createScoreDivBox:function(){  
                var dbox = document.createElement("div");  
                dbox.style.position = "absolute";  
                dbox.style.border = "1px solid black";  
                dbox.style.overflow = "hidden";  
                dbox.style.width = 100 + "px";  
                dbox.style.height = 100 + "px";  
                dbox.style.top = this.canvasDivBox.style.top;  
                dbox.style.left = 110 + parseFloat(this.canvasDivBox.style.width) + "px";  
                document.getElementsByTagName("body")[0].appendChild(dbox);  
                this.scoreDivBox = dbox;  
  
                this.scoreDivBox.innerHTML = this.score;  
            },  
            _initCanvas: function(){  
                for (var y = 0; y < this.height; y++) {  
                    this.canvas[y] = [];  
                    for (var x = 0; x < this.width; x++) {  
                        this.canvas[y][x] = 0; //无阻碍  
                        //竖向围墙  
                        if (y == 0 || y == this.height - 1) {  
                            this.canvas[y][x] = this.colorBlack;  
                        }  
                        //横向围墙  
                        if (x == 0 || x == this.width - 1) {  
                            this.canvas[y][x] = this.colorBlack;  
                        }  
                    }  
                }  
  
                this._createCanvas();  
                this.paint();  
            },  
            _createCanvas: function () {  
                var dbox = document.createElement("div");  
                dbox.style.position = "absolute";  
                dbox.style.overflow = "hidden";  
                dbox.style.width = this.width * Cell.width + "px";  
                dbox.style.height = this.height * Cell.width + "px";  
                dbox.style.top = 100 + "px";  
                dbox.style.left = 100 + "px";
                dbox.style.overflow = "hidden";
                document.getElementsByTagName("body")[0].appendChild(dbox);  
                this.canvasDivBox = dbox;  
  
                for (var y = 0; y < this.height; y++) {  
                    var dboxs = [];  
                    for (var x = 0; x < this.width; x++) {  
                        var b = document.createElement("div");  
                        b.style.position = "absolute";  
                        b.style.backgroundColor = Cell.color[this.canvas[y][x]];  
                        b.style.width = Cell.width + "px";  
                        b.style.height = Cell.width + "px";  
                        b.style.left = x * Cell.width + "px";  
                        b.style.top = y * Cell.width + "px";
                        b.style.overflow = "hidden";
                        this.canvasDivBox.appendChild(b);  
                        dboxs.push(b)  
                    }  
                    this.canvasDivCell.push(dboxs);  
                }  
            },  
  
            _canMove: function (px, py) {  
                var curMode = this.curBox.status[this.curBox.index];  
                for (var y = curMode.length - 1; y >= 0; y--) {  
                    for (var x = 0; x < curMode[y].length; x++) {  
                        var wx = (this.curBox.x + x + px), wy = (this.curBox.y + y + py);  
                        if (px != 0) {  
                            if (wx <= 0)  wx = 0;  
                            if (wx >= this.width - 1)  wx = this.width - 1;  
                            if (curMode[y][x] > 0 && wy < 0) return false;  
                            if (curMode[y][x] > 0 && this.canvas[wy][wx] > 0) return false;  
                            continue;  
                        }  
  
                        if (py != 0) {  
                            if (wy <= 0)  wy = 1;  
                            if (wy >= this.height - 1)  wy = this.height - 1;  
                            if (curMode[y][x] > 0 && wy >= this.height - 1) return false;  
                            if (curMode[y][x] > 0 && this.canvas[wy][wx] > 0) return false;  
                        }  
                    }  
                }  
                return true;  
            },  
            _canRound: function(){  
                var nextIndex = this.curBox.index + 1;  
                if (nextIndex >= 4) nextIndex = 0  
                var nextMode = this.curBox.status[nextIndex];  
                for (var y = 0; y < nextMode.length; y++) {  
                    for (var x = 0; x < nextMode[y].length; x++) {  
                        var wx = (this.curBox.x + x), wy = (this.curBox.y + y);  
                        if (nextMode[y][x] > 0 && this.canvas[wy] && this.canvas[wy][wx] != 0) {  
                            return false;  
                        }  
                    }  
                }  
                return true;  
            },  
            _isOver: function(){  
                var curMode = this.curBox.status[this.curBox.index];  
                return this.curBox.y <= 0  
            },  
            _copyBoxToCanvas: function () {  
                var curMode = this.curBox.status[this.curBox.index];  
                for (var y = 0; y < curMode.length; y++) {  
                    for (var x = 0; x < curMode[y].length; x++) {  
                        var wx = this.curBox.x + x;  
                        var wy = this.curBox.y + y;  
                        if (wy <= 0) break;  
                        if (curMode[y][x] > 0 && this.canvas[wy][wx] == 0) {  
                            this.canvas[wy][wx] = curMode[y][x]  
                        }  
                    }  
                }  
            },  
            _keypress: function(event){  
                this.isMove = false;  
                event = fixEvent(event || window.event);  
                event.preventDefault();  
                var x = 0, y = 0;  
                if (event.which == this.LEFT) {  
                    x = -1, y = 0;  
                } else if (event.which == this.UP) {  
                    if (this._canRound()) {  
                        this.curBox.around();  
                        this.curBox.draw();  
                        this.canvasDivBox.appendChild(this.curBox.divBox);  
                    }  
  
                }  
                else if (event.which == this.RIGHT) {  
                    x = 1, y = 0;  
                }  
                else if (event.which == this.DOWM) {  
                    x = 0, y = 1;  
                }  
                if (this._canMove(x, y) && event.which != this.UP) {  
                    this.curBox.move(x, y);  
                }  
                this.isMove = true;  
            },  
            _thread: function(){  
                if (this._canMove(0, 1) && this.isMove) {  
                    this.curBox.move(0, 1);  
                } else {  
                    this.isMove = false;  
                    if (this._isOver()) {  
                        clearInterval(this.time);  
                        this.scoreDivBox.innerHTML = "<br/>game over!";  
                    } else {  
                        this._copyBoxToCanvas();  
                        this._deleteLine();  
                        this.paint();  
                        this._createBox();  
  
                        if (this.score % 2 == 0) {  
                            this.delay = this.delay - this.score * this.score;  
                        }  
                        this.scoreDivBox.innerHTML = this.score;  
                    }  
                    this.isMove = true;  
                }  
            },  
  
            _deleteLine: function () {  
                //从边框内开始循环，所有减2  
                var delY = [];  
                for (var y = this.height - 2; y > 0; y--) {  
                   if(this._isDelete(y)){  
                       delY.push(y);  
                   }  
                }  
  
                while(delY.length){  
                    this.score = this.score + delY.length * 2;  
                    for (var y = delY.pop(); y > 0; y--) {  
                        for (var x = 1; x < this.width - 1; x++) {  
                            if (y - 1 <= 0) {  
                                this.canvas[y][x] = 0;  
                            }else {  
                                this.canvas[y][x] = this.canvas[y - 1][x];  
                            }  
                        }  
                    }  
                }  
            },  
            _isDelete: function (y) {  
                for (var x = 1; x < this.width - 1; x++) {  
                    if (this.canvas[y][x] == 0) {  
                        return false;  
                    }  
                }  
                return true;  
            },  
  
            _createBox: function(){  
                if(this.nextBox){  
                    this.curBox.drop();  
                    this.curBox = this.nextBox;  
                    this.curBox.init();  
                    this.nextBox = new Box();  
                    this.paintNextBox();  
                }else{  
                    this.curBox = new Box();  
                    this.nextBox = new Box();  
                    this.paintNextBox();  
                }  
  
  
  
                this.curBox.draw();  
                this.canvasDivBox.appendChild(this.curBox.divBox);  
                this.isMove = true;  
            },  
  
  
            /*------------------------------------------------------*/  
            paint: function(){  
                for (var y = 0; y < this.height; y++) {  
                    var dboxs = this.canvasDivCell[y];  
                    for (var x = 0; x < this.width; x++) {  
                        dboxs[x].style.backgroundColor = Cell.color[this.canvas[y][x]];  
                    }  
                }  
            },  
            paintNextBox:function(){  
                this.nextBox.divBox.style.left = parseFloat(this.scoreDivBox.style.left)+ this.width + "px";  
                this.nextBox.divBox.style.top = parseFloat(this.scoreDivBox.style.top) + 50 + "px";  
                document.body.appendChild(this.nextBox.divBox);  
            },  
            start: function () {  
                this._createBox();  
                document.onkeydown = applyFn(this, this._keypress);  
                this.time = setInterval(applyFn(this, this._thread), this.delay);  
            }  
        }  
  
  
        /*==============================================*/  
  
        function applyFn(obj, fn) {  
            return function () {  
                fn.apply(obj, arguments);  
            }  
        }  
  
        function callFn(obj, fn) {  
            return function () {  
                fn.apply(obj);  
            }  
        }  
  
        function fixEvent(event) {  
            if (event.preventDefault)  event.preventDefault();  
            else {  
                event.preventDefault = function () {  
                    event.returnValue = false;  
                };  
            }  
  
            if (event.which == null && (event.charCode != null || event.keyCode != null)) {  
                event.which = event.charCode != null ? event.charCode : event.keyCode;  
            }  
  
            return event;  
        }  
  
        /*==============================================*/  
        window.Tetris = Tetris;  
    })();  
  
    new Tetris();  
</script>


    

xxb2008
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前端技术搭建俄罗斯方块（内含源码）
官方推荐
06-05 2万+
通过前端基础HTML、CSS、JS来搭建一个俄罗斯方块小游戏，内附源码直接拷贝即可运行！
俄罗斯方块网页版JS
11-20
俄罗斯方块2、键盘操作：系统缺省设置使用右边的窗口，用光标操作,"←"左移一格;"→"右移一格;"↑"旋转方块;↓ 方块丢下(方块下落到底)，"End"健可以一格格的下落，用户还可以自定义习惯的按键来操作游戏。 3、计分...
网页版俄罗斯方块第2版
钢七连软件项目管理和开发
11-18 1174
网页版俄罗斯方块第1版： https://blog.csdn.net/weixin_42644456/article/details/103080277 学习技术，是个循序渐进的慢功夫。第2版已经做好，以后还有改进版。 一、工程结构： 四个文件，放在同一个文件夹下。 二、截图 三、技术原理 HTML,CSS,JS都是大一上学期的课，需要打下良好基础。 有的同学已经学过完...
Js实践之俄罗斯方块
玉案轩窗的博客
02-09 1015
前言 快到春节假期了，最近工作上没什么事情，浏览技术文章的时候看见关于俄罗斯方块相关的内容，才会起意实现下俄罗斯方块，主要目的有如下几条： 回顾下Js部分的知识 学习理解俄罗斯方块游戏的具体实现思想 具体实现 实现看下具体的实现效果，实现效果如下： 本次实现是简易版的俄罗斯方块包含基本俄罗斯方块的基本功能，本次实现的俄罗斯方块的基本功能有： 形状变换 满行消除 下一个形状提示...
HTML+CSS+JS制作【俄罗斯方块】小游戏
LuWeien的博客
12-29 3454
程序虽然很难写，却很美妙。要想把程序写好，需要写好一定的基础知识，包括编程语言、数据结构与算法。程序写得好，需要缜密的逻辑思维能力和良好的梳理基础，而且熟悉编程环境和编程工具 二、CSS代码 三、JS代码 四、代码资源分享 💡网页简单版小游戏俄罗斯方块代码资源分享点击进入仓库下载
Web版俄罗斯方块,500行代码实现
砷碲 - Shendi
09-15 3409
Hello,I'm Shendi; 做了一个Web版的小游戏，也是我制作的第一个H5小游戏 更多实战内容请进入我的实战专栏:https://blog.csdn.net/qq_41806966/category_9656338.html 目录 简介 效果视频 解析 游戏规则 页面的制作 绘制背景 画布的初始化 方块对象 游戏逻辑执行 按键监听 交互事件(*) 思路 结果判断,加分机制 暂停游戏 游戏结束 在线试玩 源码 简介 拥有俄罗斯方块的...
JSP版俄罗斯发方块+用户积分排行榜
钢七连软件项目管理和开发
11-18 1082
一、游戏截图 二、查看所有成绩 三、技术原理： 学习过程是循序渐进的： 1.俄罗斯方块第1版：能移动，能接收按键，刷新画面。 https://blog.csdn.net/weixin_42644456/article/details/103080277 2.俄罗斯方块第2版：单机版做完。 https://blog.csdn.net/weixin_42644456/articl...
js版俄罗斯方块（二）
斌斌(Java)
03-27 2260
之前曾发过一个js版的俄罗斯方块，界面比较简单，Bug也不少。抽空重构了一下，加入了javaScript面向对象的知识，修复了一些明显的BUG。 斌斌 (给我写信) 原创博文（http://blog.csdn.net/binbinxyz），转载请注明出处！ 源码（下载：http://download.csdn.net/detail/binbinxyz/5186774）公开如下：
vue实现俄罗斯方块初级版本
weixin_41013537的博客
11-11 2312
最近乘工作闲暇，做了一个俄罗斯方块，里面用了较多es6的语法，但是基本上都做了注释 先上思路 俄罗斯的方块简单指出在于他有固定的集中图形 大概有个印象，本身加变化总共19种图像 1、先画一个游戏区方块（我的思路是定义行列，然后根据行列先画出一个一维数组，把一位数组转为二位数组） 2、去解决碰撞跟触底的判断(这是一个难点，还是要找规律） 我的思路是这样 比如说这个图形，如果向下做触底...
基于WEB的俄罗斯方块(JS+HTML+CSS)
m0_59024303的博客
06-26 2507
虽然只是个很简答的小游戏，时间安排上：一天逻辑功能代码五天美化样式完善功能。。实现上比较简单，只用到了HTML+CSS+JavaScript。代码部分一会会做一个详细的解释说明，风格上主要是新拟态风格，看上去比较简约大气。 先来列举一下这个游戏的主要功能和一些扩展的功能。 主要功能 1、能够实现AD 控制不同形状方块的移动 2、空格可以直接下落、S可以加速方块下落速度 3、W可以控制方块逆时针旋转 4...
minetgm:扫雷x俄罗斯方块
05-23
扫雷x俄罗斯方块：TGM 与《俄罗斯方块TGM》起步相对困难并且变得越来越困难类似，此处的目标是提供一个版本，该版本需要解决多个难度不断增加的电路板。 生成的每个板在逻辑上都是可解决的，并且从开口开始。 第一次...
java俄罗斯方块源码-Tetris-SFML:使用C++和SFML库制作的俄罗斯方块
06-05
我的第二个选择是 Javascript。 我很难在两者之间做出决定。 俄罗斯方块是一款非常适合在浏览器中运行的游戏，Javascript 本身非常轻量级，不需要任何额外的（图形）库来显示游戏，因为您只需使用其内置画布即可。 ...
疯狂HTML 5+CSS 3+JavaScript讲义（第2版）+源代码
11-19
目录 第1章　HTML 5简介 1 ...第20章　HTML 5的疯狂俄罗斯方块 637 20.1　俄罗斯方块简介 638 20.2　开发游戏界面 639 20.3　俄罗斯方块的数据模型 640 20.4　实现游戏逻辑 644 20.5　本章小结 654
达内java培训目录
02-06
2.开班 2周内，贯穿着 Java 语言基础及 Java 面向对象的学习，学员将完成专业版的俄罗斯方块项目 3. 开班一个半月内，贯穿 JavaSE及数据库的学习将完成 T-DMS 数据 采集系统项目 • 整个系统由 DMS 采集端、DMS ...
HttpClient--HttpGet的使用样式
热门推荐
xxb2008的专栏
05-30 2万+
httpclient import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpGet; i
Aio--Java异步IO的 Socket Demo
xxb2008的专栏
01-05 9509
package com.vdebug.aio.socket; import java.io.IOException; import java.net.InetSocketAddress; import java.net.StandardSocketOptions; import java.nio.ByteBuffer; import java.nio.CharBuffer; import jav
NIO--SocketChannel发送HTTP请求
xxb2008的专栏
05-28 4994
import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SocketChannel; import java.nio.charset.Charset; /** * Created with . * Date: 14-5-27 * Time: 上午11:38 * To c
Nio--Selector实现简易的http服务器
xxb2008的专栏
12-30 2075
标题貌似很牛，但这里只是我的对Nio--Selector的测试demo，没有什么特别。再深化开发一下，实现一个http服务器也不是难事。   package com.vdebug.nio.selector; import java.io.IOException; import java.net.InetSocketAddress; import java.net.ServerSocket;
俄罗斯方块linux版本下载
最新发布
10-14
若您想要下载俄罗斯方块的Linux版本，可以按照以下步骤进行操作。 首先，打开您的Linux系统，确保已连接到互联网。 其次，使用您喜欢的网页浏览器，访问软件下载网站，如CNET、Softpedia或SourceForge等。在网站的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值