1.音频cr是源码什么意思？
2.markdown-it 原理解析
3.CR、OBV代码
4.“CR”作为“代码发布”的英文缩写，其流行度和应用场景如何？
5.筹码集中度选股指标公式源码
6.chromium简介

音频cr是源码什么意思？

       CR是一个英文单词的缩写，全称为“Credit Rating（信用评级）”。源码在金融行业，源码CR通常用于描述某个公司、源码机构或国家的源码源码 o2o 上门信用评级情况。信用评级是源码金融市场中非常重要的一环，它直接关系到融资成本、源码债券价格等经济指标。源码

       除了在金融领域中，源码CR还有其他的源码含义。在IT行业中，源码CR指的源码是“Code Review（代码审查）”，也就是源码对源代码的检查和评估。这种评估可以帮助检测代码的源码错误和漏洞，提高代码的质量和安全性。

       此外，在医学界中，CR代表了“Computed Radiography（计算机辅助摄影技术）”。这一技术被广泛用于诊断和治疗方面，可以生成高分辨率的X射线图像，帮助医生准确诊断疾病和制定治疗方案。

markdown-it 原理解析

       在《一篇带你用 VuePress + Github Pages 搭建博客》中，我们使用 VuePress 搭建了一个博客，最终的效果查看： TypeScript 中文文档。

       在搭建博客的过程中，我们出于实际的需求，在《VuePress 博客优化之拓展 Markdown 语法》中讲解了如何写一个 markdown-it插件，本篇我们将深入markdown-it的源码，讲解 markdown-it的执行原理，旨在让大家对 markdown-it有更加深入的818源码短信理解。

       引用 markdown-it Github 仓库的介绍：

       Markdown parser done right. Fast and easy to extend.

       可以看出markdown-it是一个 markdown 解析器，并且易于拓展。

       其演示地址为： markdown-it.github.io/

       markdown-it具有以下几个优势：

       使用源码解析

       我们查看markdown-it 的 入口代码，可以发现其代码逻辑清晰明了：

       从render方法中也可以看出，其渲染分为两个过程：

       跟 Babel 很像，不过 Babel 是转换为抽象语法树（AST），而markdown-it 没有选择使用 AST，主要是为了遵循 KISS(Keep It Simple, Stupid) 原则。

       Tokens

       那 Tokens 长什么样呢？我们不妨在 演示页面中尝试一下：

       可以看出# header生成的 Token 格式为（注：这里为了展示方便，简化了）：

       具体 Token 里的字段含义可以查看 Token Class。

       通过这个简单的 Tokens 示例也可以看出 Tokens 和 AST 的区别：

       Parse

       查看 parse 方法相关的代码：

       可以看到其具体执行的代码，应该是写在了./parse_core 里，查看下 parse_core.js 的代码：

       可以看出，Parse 过程默认有 6 条规则，其主要作用分别是：

       1. normalize

       在 CSS 中，我们使用normalize.css 抹平各端差异，这里也是一样的逻辑，我们查看 normalize 的代码，其实很简单：

       我们知道\n是匹配一个换行符，\r是匹配一个回车符，那这里为什么要将 \r\n替换成 \n 呢?

       我们可以在阮一峰老师的这篇 《回车与换行》中找到\r\n出现的历史：

       在计算机还没有出现之前，有一种叫做电传打字机（Teletype Model ）的玩意，每秒钟可以打个字符。但是它有一个问题，就是打完一行换行的时候，要用去0.2秒，正好可以打两个字符。要是在这0.2秒里面，又有新的字符传过来，那么这个字符将丢失。协议注册源码 于是，研制人员想了个办法解决这个问题，就是在每行后面加两个表示结束的字符。一个叫做"回车"，告诉打字机把打印头定位在左边界；另一个叫做"换行"，告诉打字机把纸向下移一行。 这就是"换行"和"回车"的来历，从它们的英语名字上也可以看出一二。 后来，计算机发明了，这两个概念也就被般到了计算机上。那时，存储器很贵，一些科学家认为在每行结尾加两个字符太浪费了，加一个就可以。于是，就出现了分歧。 Unix系统里，每行结尾只有""，即"\n"；Windows系统里面，每行结尾是""，即"\r\n"；Mac系统里，每行结尾是""。一个直接后果是，Unix/Mac系统下的文件在Windows里打开的话，所有文字会变成一行；而Windows里的文件在Unix/Mac下打开的话，在每行的结尾可能会多出一个^M符号。

       之所以将\r\n替换成 \n其实是 遵循规范：

       A line ending is a newline (U+A), a carriage return (U+D) not followed by a newline, or a carriage return and a following newline.

       其中 U+A 表示换行(LF) ，U+D 表示回车(CR) 。

       除了替换回车符外，list源码介绍源码里还替换了空字符，在 正则中，\0表示匹配 NULL（U+）字符，根据 WIKI 的解释：

       空字符（Null character）又称结束符，缩写 NUL，是一个数值为 0 的控制字符。 在许多字符编码中都包括空字符，包括ISO/IEC （ASCII）、C0控制码、通用字符集、Unicode和EBCDIC等，几乎所有主流的编程语言都包括有空字符 这个字符原来的意思类似NOP指令，当送到列表机或终端时，设备不需作任何的动作（不过有些设备会错误的打印或显示一个空白）。

       而我们将空字符替换为\uFFFD，在 Unicode 中，\uFFFD表示替换字符：

       之所以进行这个替换，其实也是遵循规范，我们查阅 CommonMark spec 2.3 章节：

       For security reasons, the Unicode character U+ must be replaced with the REPLACEMENT CHARACTER (U+FFFD).

       我们测试下这个效果：

       效果如下，你会发现原本不可见的空字符被替换成替换字符后，展示了出来：

       2. block

       block 这个规则的作用就是找出 block，生成 tokens，那什么是 block？什么是 inline 呢？我们也可以在 CommonMark spec 中的 Blocks and inlines 章节 找到答案：

       We can think of a document as a sequence of blocks—structural elements like paragraphs, block quotations, lists, headings, rules, and code blocks. Some blocks (like block quotes and list items) contain other blocks; others (like headings and paragraphs) contain inline content—text, links, emphasized text, images, code spans, and so on.

       翻译一下就是：

       我们认为文档是由一组 blocks 组成，结构化的元素类似于段落、引用、列表、标题、代码区块等。一些 blocks （像引用和列表）可以包含其他 blocks，其他的蔬果云源码一些 blocks（像标题和段落）则可以包含 inline 内容，比如文字、链接、 强调文字、、代码片段等等。

       当然在markdown-it中，哪些会识别成 blocks，可以查看 parser_block.js，这里同样定义了一些识别和 parse 的规则：

       关于这些规则我挑几个不常见的说明一下:

       code 规则用于识别 Indented code blocks (4 spaces padded)，在 markdown 中:

       fence 规则用于识别 Fenced code blocks，在markdown 中：

       hr 规则用于识别换行，在 markdown 中：

       reference 规则用于识别 reference links，在 markdown 中：

       html_block 用于识别 markdown 中的 HTML block 元素标签，就比如div。

       lheading 用于识别 Setext headings，在 markdown 中：

       3. inline

       inline 规则的作用则是解析 markdown 中的 inline，然后生成 tokens，之所以 block 先执行，是因为 block 可以包含 inline ，解析的规则可以查看 parser_inline.js：

       关于这些规则我挑几个不常见的说明一下:

       newline规则用于识别 \n，将 \n 替换为一个 hardbreak 类型的 token

       backticks 规则用于识别反引号：

       entity 规则用于处理 HTML entity，比如 { ``¯``"等：

       4. linkify

       自动识别链接

       5. replacements

       将(c)`` (C) 替换成 ©，将 替换成 ，将 !!!!! 替换成 !!!，诸如此类：

       6. smartquotes

       为了方便印刷，对直引号做了处理：

       Render

       Render 过程其实就比较简单了，查看 renderer.js 文件，可以看到内置了一些默认的渲染 rules：

       其实这些名字也是 token 的 type，在遍历 token 的时候根据 token 的 type 对应这里的 rules 进行执行，我们看下 code_inline 规则的内容，其实非常简单：

       自定义 Rules

       至此，我们对 markdown-it 的渲染原理进行了简单的了解，无论是 Parse 还是 Render 过程中的 Rules，markdown-it 都提供了方法可以自定义这些 Rules，这些也是写 markdown-it 插件的关键，这些后续我们会讲到。

       系列文章

       博客搭建系列是我至今写的唯一一个偏实战的系列教程，讲解如何使用 VuePress 搭建博客，并部署到 GitHub、Gitee、个人服务器等平台。

       微信：「mqyqingfeng」，加我进冴羽唯一的读者群。

       如果有错误或者不严谨的地方，请务必给予指正，十分感谢。如果喜欢或者有所启发，欢迎 star，对作者也是一种鼓励。

CR、OBV代码

       MID := (HIGH+LOW+CLOSE)/3;

       CR:SUM(MAX(0,HIGH-REF(MID,1)),M)/SUM(MAX(0,REF(MID,1)-L),M)*;

       MA1:REF(MA(CR,P1),P1/2.5+1);

       MA2:REF(MA(CR,P2),P2/2.5+1);

       MA3:REF(MA(CR,P3),P3/2.5+1);

       å…¶ä¸­å‚数：M P1:5 P2: P3:

       obv

       VA:=IF(CLOSE>REF(CLOSE,1),VOL,-VOL);

       OBV:SUM(IF(CLOSE=REF(CLOSE,1),0,VA),0);

       MAOBV:MA(OBV,);

“CR”作为“代码发布”的英文缩写，其流行度和应用场景如何？

       在计算机术语中，"CR"是一个广泛使用的缩写，它代表"Code Release"，中文直译为“代码发布”。这个术语主要用于描述软件开发过程中的一个重要步骤，即将源代码公开给用户或团队进行测试、评估和改进。CR在软件开发领域中具有较高的流行度，因为严格的代码管理对于确保产品质量和安全性至关重要。

       CR的中文解释为“代码发布”，其拼音为dài mǎ fā bù。它在英语中的应用领域主要是软件开发和版本控制，特别是在需要透明度和合规性的项目中。例如，MVC源代码的发布在产品开发周期中体现了CR的严格治理标准。此外，像Usergrid这样的平台，其源代码的首次公开也是CR的一个典型应用，这表明了代码发布在移动和富客户端应用中的重要性。

       微软也曾认识到代码发布的重要性，尤其是在源代码管理上。而XSL作为代码的一种形式，任何更改都需要通过新的代码发布来实现，这再次强调了CR在技术更新中的不可或缺性。

       总的来说，"CR"作为"Code Release"的缩写，不仅是一个技术术语，也是软件生命周期管理中不可或缺的一个环节。它反映了现代软件开发过程中对代码质量控制和透明度的重视。

筹码集中度选股指标公式源码

       筹码集中度选股指标公式源码如下：

       源码：

       1. CR=× 累积百分比。其中，筹码峰值高度是指筹码分布曲线上的最高点对应的值。当前价格是指当前股票的市场价格。累积百分比是根据筹码分布情况进行累积计算的。通过这个公式计算出来的CR值越大，筹码越集中，越容易形成一致性方向的力量。

       2.个股选筹代码可以通过某些软件的选股器进行操作。这些软件提供了选股方案以及详细的指标，便于根据选股公式直接筛选个股，进一步辅助决策投资目标股票池的选择过程。此过程中也可以对软件公式进行调整以适应自己的投资策略和需求，即根据个人对筹码集中度等因素的判断和需求设定条件。在此基础上形成的股票组合将有助于投资决策的实施和风险管理。最终选择的股票应该满足所选软件选股器的各项参数条件以及筹码集中度的需求标准。注意关注股票市场动态和基本面信息，以做出明智的投资决策。同时，也需要对选股公式进行持续优化和改进，以适应市场变化和投资策略的调整。以上内容仅为参考，实际操作需谨慎决策。

       解释：筹码集中度是评估股票筹码分布状况的重要指标之一，它反映了股票的持有者集中程度以及筹码的流动性情况。在选股过程中，投资者可以通过计算股票的筹码集中度来选择投资目标股票池。CR值的计算方式为：通过筹码峰值高度和当前价格的乘积与累积百分比的计算得到最终数据结果，可以评估该股票的筹码集中度水平，并通过设置适当的门槛条件筛选出符合要求的股票组合进行投资决策。此外，投资者也可以通过软件选股器进行辅助决策，根据个人投资策略和需求调整软件公式以适应市场变化和投资需求的变化。最终选择股票时需要注意股票市场动态和基本面信息的影响，同时持续优化和改进选股公式以适应市场变化和投资策略的调整。

chromium简介

       Chromium是由Google主导开发的网页浏览器引擎，旨在构建一个安全、稳定且快速的通用浏览器。它基于BSD许可证等自由版权，发行并提供开放源代码。Chromium的开发始于年，旨在实现简单、高速、稳定与安全的理念。其架构采用了WebKit排版引擎、Safari的部分源代码与Firefox的成果，并使用了Google自主研发的V8引擎来提升JavaScript的解析效率。Chromium提供了诸如“沙盒”、“黑名单”、“无痕浏览”等功能，以实现更稳定与安全的网页浏览环境。Chromium相当于Chrome的工程版或实验版，新功能会率先在Chromium上实现，然后经过验证后应用到Chrome上。Chromium的更新速度非常快，每隔数小时就会发布新的开发版本。Chromium可以免安装使用，只需下载ZIP封装版并解压缩即可。理论上，Chrome也可以免安装，但Google主要提供安装版。Chromium和Chrome所使用的webkit内核目前被认为是最快的网页浏览方式。

       基于Chromium开源代码（基于webkit内核）的浏览器包括极速浏览器、枫树浏览器、太阳花浏览器、世界之窗极速版以及傲游浏览器。搜狗高速浏览器与QQ浏览器官网虽未明确提及Chromium，仅提到使用webkit内核，但经网友测试，这两款浏览器极有可能也是基于Chromium开发，只是官方未正式承认。

       简而言之，Chromium作为Google Chrome浏览器的底层引擎，不仅提供了强大的网页浏览功能，而且因其开放性和快速更新，吸引了众多基于其内核的浏览器开发者。基于Chromium的浏览器不仅共享了其高效、稳定与安全的特性，也为用户提供了一个广泛且多元化的浏览体验选择。

扩展资料

       铬（chromium）元素符号Cr，银白色金属，在元素周期表中属 ⅥB族， 铬矿原子序数，原子量.，体心立方晶体，常见化合价为+3、+6和+2。年法国化学家沃克兰 (L.N.Vauquelin)在西伯利亚红铅矿（铬铅矿）中发现一种新元素，次年用碳还原，得金属铬。因为铬能够生成美丽多色的化合物，根据希腊字chroma（颜色）命名为chromium

求俄罗斯方块源代码

       手机游戏---俄罗斯方块

       俄罗斯方块——java源代码提供

       import java.awt.*;

       import java.awt.event.*;

       //俄罗斯方块类

       public class ERS_Block extends Frame{

       public static boolean isPlay=false;

       public static int level=1,score=0;

       public static TextField scoreField,levelField;

       public static MyTimer timer;

       GameCanvas gameScr;

       public static void main(String[] argus){

       ERS_Block ers = new ERS_Block("俄罗斯方块游戏 V1.0 Author:Vincent");

       WindowListener win_listener = new WinListener();

       ers.addWindowListener(win_listener);

       }

       //俄罗斯方块类的构造方法

       ERS_Block(String title){

       super(title);

       setSize(,);

       setLayout(new GridLayout(1,2));

       gameScr = new GameCanvas();

       gameScr.addKeyListener(gameScr);

       timer = new MyTimer(gameScr);

       timer.setDaemon(true);

       timer.start();

       timer.suspend();

       add(gameScr);

       Panel rightScr = new Panel();

       rightScr.setLayout(new GridLayout(2,1,0,));

       rightScr.setSize(,);

       add(rightScr);

       //右边信息窗体的布局

       MyPanel infoScr = new MyPanel();

       infoScr.setLayout(new GridLayout(4,1,0,5));

       infoScr.setSize(,);

       rightScr.add(infoScr);

       //定义标签和初始值

       Label scorep = new Label("分数:",Label.LEFT);

       Label levelp = new Label("级数:",Label.LEFT);

       scoreField = new TextField(8);

       levelField = new TextField(8);

       scoreField.setEditable(false);

       levelField.setEditable(false);

       infoScr.add(scorep);

       infoScr.add(scoreField);

       infoScr.add(levelp);

       infoScr.add(levelField);

       scorep.setSize(new Dimension(,));

       scoreField.setSize(new Dimension(,));

       levelp.setSize(new Dimension(,));

       levelField.setSize(new Dimension(,));

       scoreField.setText("0");

       levelField.setText("1");

       //右边控制按钮窗体的布局

       MyPanel controlScr = new MyPanel();

       controlScr.setLayout(new GridLayout(5,1,0,5));

       rightScr.add(controlScr);

       //定义按钮play

       Button play_b = new Button("开始游戏");

       play_b.setSize(new Dimension(,));

       play_b.addActionListener(new Command(Command.button_play,gameScr));

       //定义按钮Level UP

       Button level_up_b = new Button("提高级数");

       level_up_b.setSize(new Dimension(,));

       level_up_b.addActionListener(new Command(Command.button_levelup,gameScr));

       //定义按钮Level Down

       Button level_down_b =new Button("降低级数");

       level_down_b.setSize(new Dimension(,));

       level_down_b.addActionListener(new Command(Command.button_leveldown,gameScr));

       //定义按钮Level Pause

       Button pause_b =new Button("游戏暂停");

       pause_b.setSize(new Dimension(,));

       pause_b.addActionListener(new Command(Command.button_pause,gameScr));

       //定义按钮Quit

       Button quit_b = new Button("退出游戏");

       quit_b.setSize(new Dimension(,));

       quit_b.addActionListener(new Command(Command.button_quit,gameScr));

       controlScr.add(play_b);

       controlScr.add(level_up_b);

       controlScr.add(level_down_b);

       controlScr.add(pause_b);

       controlScr.add(quit_b);

       setVisible(true);

       gameScr.requestFocus();

       }

       }

       //重写MyPanel类，使Panel的四周留空间

       class MyPanel extends Panel{

       public Insets getInsets(){

       return new Insets(,,,);

       }

       }

       //游戏画布类

       class GameCanvas extends Canvas implements KeyListener{

       final int unitSize = ; //小方块边长

       int rowNum; //正方格的行数

       int columnNum; //正方格的列数

       int maxAllowRowNum; //允许有多少行未削

       int blockInitRow; //新出现块的起始行坐标

       int blockInitCol; //新出现块的起始列坐标

       int [][] scrArr; //屏幕数组

       Block b; //对方快的引用

       //画布类的构造方法

       GameCanvas(){

       rowNum = ;

       columnNum = ;

       maxAllowRowNum = rowNum - 2;

       b = new Block(this);

       blockInitRow = rowNum - 1;

       blockInitCol = columnNum/2 - 2;

       scrArr = new int [][];

       }

       //初始化屏幕，并将屏幕数组清零的方法

       void initScr(){

       for(int i=0;i<rowNum;i++)

       for (int j=0; j<columnNum;j++)

       scrArr[j]=0;

       b.reset();

       repaint();

       }

       //重新刷新画布方法

       public void paint(Graphics g){

       for(int i = 0; i < rowNum; i++)

       for(int j = 0; j < columnNum; j++)

       drawUnit(i,j,scrArr[j]);

       }

       //画方块的方法

       public void drawUnit(int row,int col,int type){

       scrArr[row][col] = type;

       Graphics g = getGraphics();

       tch(type){ //表示画方快的方法

       case 0: g.setColor(Color.black);break; //以背景为颜色画

       case 1: g.setColor(Color.blue);break; //画正在下落的方块

       case 2: g.setColor(Color.magenta);break; //画已经落下的方法

       }

       g.fill3DRect(col*unitSize,getSize().height-(row+1)*unitSize,unitSize,unitSize,true);

       g.dispose();

       }

       public Block getBlock(){

       return b; //返回block实例的引用

       }

       //返回屏幕数组中(row,col)位置的属性值

       public int getScrArrXY(int row,int col){

       if (row < 0 || row >= rowNum || col < 0 || col >= columnNum)

       return(-1);

       else

       return(scrArr[row][col]);

       }

       //返回新块的初始行坐标方法

       public int getInitRow(){

       return(blockInitRow); //返回新块的初始行坐标

       }

       //返回新块的初始列坐标方法

       public int getInitCol(){

       return(blockInitCol); //返回新块的初始列坐标

       }

       //满行删除方法

       void deleteFullLine(){

       int full_line_num = 0;

       int k = 0;

       for (int i=0;i<rowNum;i++){

       boolean isfull = true;

       L1:for(int j=0;j<columnNum;j++)

       if(scrArr[j] == 0){

       k++;

       isfull = false;

       break L1;

       }

       if(isfull) full_line_num++;

       if(k!=0 && k-1!=i && !isfull)

       for(int j = 0; j < columnNum; j++){

       if (scrArr[j] == 0)

       drawUnit(k-1,j,0);

       else

       drawUnit(k-1,j,2);

       scrArr[k-1][j] = scrArr[j];

       }

       }

       for(int i = k-1 ;i < rowNum; i++){

       for(int j = 0; j < columnNum; j++){

       drawUnit(i,j,0);

       scrArr[j]=0;

       }

       }

       ERS_Block.score += full_line_num;

       ERS_Block.scoreField.setText(""+ERS_Block.score);

       }

       //判断游戏是否结束方法

       boolean isGameEnd(){

       for (int col = 0 ; col <columnNum; col ++){

       if(scrArr[maxAllowRowNum][col] !=0)

       return true;

       }

       return false;

       }

       public void keyTyped(KeyEvent e){

       }

       public void keyReleased(KeyEvent e){

       }

       //处理键盘输入的方法

       public void keyPressed(KeyEvent e){

       if(!ERS_Block.isPlay)

       return;

       tch(e.getKeyCode()){

       case KeyEvent.VK_DOWN:b.fallDown();break;

       case KeyEvent.VK_LEFT:b.leftMove();break;

       case KeyEvent.VK_RIGHT:b.rightMove();break;

       case KeyEvent.VK_SPACE:b.leftTurn();break;

       }

       }

       }

       //处理控制类

       class Command implements ActionListener{

       static final int button_play = 1; //给按钮分配编号

       static final int button_levelup = 2;

       static final int button_leveldown = 3;

       static final int button_quit = 4;

       static final int button_pause = 5;

       static boolean pause_resume = true;

       int curButton; //当前按钮

       GameCanvas scr;

       //控制按钮类的构造方法

       Command(int button,GameCanvas scr){

       curButton = button;

       this.scr=scr;

       }

       //按钮执行方法

       public void actionPerformed (ActionEvent e){

       tch(curButton){

       case button_play:if(!ERS_Block.isPlay){

       scr.initScr();

       ERS_Block.isPlay = true;

       ERS_Block.score = 0;

       ERS_Block.scoreField.setText("0");

       ERS_Block.timer.resume();

       }

       scr.requestFocus();

       break;

       case button_levelup:if(ERS_Block.level < ){

       ERS_Block.level++;

       ERS_Block.levelField.setText(""+ERS_Block.level);

       ERS_Block.score = 0;

       ERS_Block.scoreField.setText(""+ERS_Block.score);

       }

       scr.requestFocus();

       break;

       case button_leveldown:if(ERS_Block.level > 1){

       ERS_Block.level--;

       ERS_Block.levelField.setText(""+ERS_Block.level);

       ERS_Block.score = 0;

       ERS_Block.scoreField.setText(""+ERS_Block.score);

       }

       scr.requestFocus();

       break;

       case button_pause:if(pause_resume){

       ERS_Block.timer.suspend();

       pause_resume = false;

       }else{

       ERS_Block.timer.resume();

       pause_resume = true;

       }

       scr.requestFocus();

       break;

       case button_quit:System.exit(0);

       }

       }

       }

       //方块类

       class Block {

       static int[][] pattern = {

       ,//用十六进至表示，本行表示长条四种状态

       ,

       ,

       ,

       ,

       ,

       };

       int blockType; //块的模式号（0-6）

       int turnState; //块的翻转状态（0-3）

       int blockState; //快的下落状态

       int row,col; //块在画布上的坐标

       GameCanvas scr;

       //块类的构造方法

       Block(GameCanvas scr){

       this.scr = scr;

       blockType = (int)(Math.random() * )%7;

       turnState = (int)(Math.random() * )%4;

       blockState = 1;

       row = scr.getInitRow();

       col = scr.getInitCol();

       }

       //重新初始化块，并显示新块

       public void reset(){

       blockType = (int)(Math.random() * )%7;

       turnState = (int)(Math.random() * )%4;

       blockState = 1;

       row = scr.getInitRow();

       col = scr.getInitCol();

       dispBlock(1);

       }

       //实现“块”翻转的方法

       public void leftTurn(){

       if(assertValid(blockType,(turnState + 1)%4,row,col)){

       dispBlock(0);

       turnState = (turnState + 1)%4;

       dispBlock(1);

       }

       }

       //实现“块”的左移的方法

       public void leftMove(){

       if(assertValid(blockType,turnState,row,col-1)){

       dispBlock(0);

       col--;

       dispBlock(1);

       }

       }

       //实现块的右移

       public void rightMove(){

       if(assertValid(blockType,turnState,row,col+1)){

       dispBlock(0);

       col++;

       dispBlock(1);

       }

       }

       //实现块落下的操作的方法

       public boolean fallDown(){

       if(blockState == 2)

       return(false);

       if(assertValid(blockType,turnState,row-1,col)){

       dispBlock(0);

       row--;

       dispBlock(1);

       return(true);

       }else{

       blockState = 2;

       dispBlock(2);

       return(false);

       }

       }

       //判断是否正确的方法

       boolean assertValid(int t,int s,int row,int col){

       int k = 0x;

       for(int i = 0; i < 4; i++){

       for(int j = 0; j < 4; j++){

       if((int)(pattern[t][s]&k) != 0){

       int temp = scr.getScrArrXY(row-i,col+j);

       if (temp<0||temp==2)

       return false;

       }

       k = k >> 1;

       }

       }

       return true;

       }

       //同步显示的方法

       public synchronized void dispBlock(int s){

       int k = 0x;

       for (int i = 0; i < 4; i++){

       for(int j = 0; j < 4; j++){

       if(((int)pattern[blockType][turnState]&k) != 0){

       scr.drawUnit(row-i,col+j,s);

       }

       k=k>>1;

       }

       }

       }

       }

       //定时线程

       class MyTimer extends Thread{

       GameCanvas scr;

       public MyTimer(GameCanvas scr){

       this.scr = scr;

       }

       public void run(){

       while(true){

       try{

       sleep((-ERS_Block.level + 1)*);

       }

       catch(InterruptedException e){ }

       if(!scr.getBlock().fallDown()){

       scr.deleteFullLine();

       if(scr.isGameEnd()){

       ERS_Block.isPlay = false;

       suspend();

       }else

       scr.getBlock().reset();

       }

       }

       }

       class WinListener extends WindowAdapter{

       public void windowClosing (WindowEvent l){

       System.exit(0);

       }

       }