简单的俄罗斯方块

2010-02-11 02:22:09 528 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

C++编写简单的俄罗斯方块游戏代码地址如下：http://www.demodashi.com/demo/14593.html C++编写简单的俄罗斯方块游戏使用C++编写一个简单的俄罗斯方块游戏。 1 环境要求使用C++图形库SFML，官网下载地址为https://www.sfml-dev.org/download.php 解压安装假设安装路径为：C:\Program Files\SFML VS配置新建项... 阅读详情

完全用自己的思路实现, 不过目前还有很多BUG, 懒得改了. 思路已经实现了,分享出来大家研究学习.

...全文

数学建模传染病模型_【数学建模】之传染病模型点击【拇指笔记】，关注我的公众号。SE模型缺点：没有考虑接触到的人中还有一部分病人，所以所有人并不会全部被感染。建立模型：已感染人数(病人)每个病人每天有效接触(足以使人致病)人数为根据(1)(2)可以建立模型：等式两边同时除以\Delta t由导数定义有同时，取\Delta t = 1天由(1)(5)两式可得最终的模型：Logistic模型缺点：区分已感染者(病人)和未感染者(健康人)... 阅读详情

pauliuyou

Java SE 62,620 成员 307,251 内容

+ 关注 + 加入社区

切换为时间正序

xtsqianli 2010-02-27

打赏
举报

你们都是猛人菜鸟来过

pauliuyou 2010-02-27

打赏
举报

我用的是多态实现，自己可以重写绘图方法，可以用各种图形来表示方块，而且可以扩展成其它各种类型的游戏。比如贪吃蛇，赛车等。。

wangshu3000 2010-02-23

打赏
举报

好长看90行的实现

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class Terris extends JFrame implements Runnable, KeyListener {

    private short isPlaying=0/*是否游戏,声明*/,xOffSet = 3/*当前方块的横坐标*/, yOffSet = 0/*当前方块的纵坐标*/, blockType = (short) Math.round(Math.random() * 6)/*随即初始方块类型*/, blockRotation = 0/*初始方块旋转角度*/, blockColor = (short) Math.round(Math.random() * 5)/*随即初始方块颜色*/;

    private short matrix[][] = new short[21][10];/*整个画布21*10的矩阵*/

    private short block[][][][] = {{{{ 0, 1, 0, 0 },{ 0, 1, 0, 0 },{ 0, 1, 0, 0 },{ 0, 1, 0, 0 }},/* l */{{ 0, 0, 0, 0 }, { 1, 1, 1, 1 }, { 0, 0, 0, 0 },{ 0, 0, 0, 0 } } },/*-*/{{ { 0, 0, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 1, 0 },{ 0, 0, 0, 0 } },/* z */{ { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 0, 1, 1, 0 },{ 0, 1, 0, 0 } } },/* z| */{{ { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 1, 1, 0, 0 },{ 0, 0, 0, 0 } },/* xz */{ { 0, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 0, 1, 0 },{ 0, 0, 0, 0 } } },/* xz| */{ { { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 }, { 0, 0, 0, 0 } } },/** []*/{{ { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 },{ 0, 0, 0, 0 } },{ { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 0, 1, 0 },{ 0, 0, 0, 0 } },{ { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 1, 1, 0, 0 },{ 0, 0, 0, 0 } },{ { 1, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 },{ 0, 0, 0, 0 } } },/* f */{{ { 1, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 },{ 0, 0, 0, 0 } },{ { 0, 0, 1, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 },{ 0, 0, 0, 0 } },{ { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 1, 0 },{ 0, 0, 0, 0 } },{ { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 1, 0, 0, 0 },{ 0, 0, 0, 0 } } },/* xf */ {{ { 0, 1, 0, 0 }, { 1, 1, 1, 0 }, { 0, 0, 0, 0 },{ 0, 0, 0, 0 } },{ { 0, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 },{ 0, 0, 0, 0 } },{ { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 1, 0, 0 },{ 0, 0, 0, 0 } },{ { 0, 1, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 0, 0 },{ 0, 0, 0, 0 } } } };/* t *//*保存所有方块的4维矩阵,分别是:方块类型、方块旋转、方块x坐标、方块y坐标*/

    private Image[] images = {new ImageIcon("D:/Java/eclipse/workspace/Terris/src/img/Red.gif").getImage(),new ImageIcon("D:/Java/eclipse/workspace/Terris/src/img/Blue.gif").getImage(),new ImageIcon(("D:/Java/eclipse/workspace/Terris/src/img/Pink.gif")).getImage(),new ImageIcon(("D:/Java/eclipse/workspace/Terris/src/img/BBlue.gif")).getImage(),new ImageIcon(("D:/Java/eclipse/workspace/Terris/src/img/Orange.gif")).getImage(),new ImageIcon(("D:/Java/eclipse/workspace/Terris/src/img/Green.gif")).getImage(),new ImageIcon("D:/Java/eclipse/workspace/Terris/src/img/Red.gif").getImage()};/*各种颜色方块图片*/

    public Terris() {

        setSize(160, 335);/*窗口大小*/

        setVisible(true);/*可视*/

        createBufferStrategy(2);/*对当前窗口创建双缓冲*/

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);/*设置关闭按钮事件*/

        addKeyListener(this);/*添加按键响应*/

    }

    public void paint(Graphics g) {

        Graphics tg = this.getBufferStrategy().getDrawGraphics();/*获取后台缓冲画布*/

        tg.fillRect(5, 30, 150, 340);/*涂黑背景*/

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

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

                if (matrix[i][j] != 0)

                    tg.drawImage(images[matrix[i][j]], j * 15 + 5, i * 15 + 15,null);/*根据后台背景的矩阵绘制已经固定的各方块*/

                if (i < 4 && j < 4&& block[blockType][blockRotation][i][j] != 0)

                    tg.drawImage(images[blockColor + 1],((j + xOffSet) * 15) + 5,((i + yOffSet) * 15) + 15, null);/*绘制当前能控制的方块*/

            }

        this.getBufferStrategy().show();/*切换后台画布到前台显示*/

    }

    public static void main(String[] args) {

        new Thread(new Terris()).start();//初始化界面并创建启动游戏线程

    }

    public void run() {

        while (isPlaying==0)/*当游戏正在进行 不断下落*/

            try {

                if (check(0, 0, 0, 1))/*最后一个参数1 是下落 表示下落一格 其他参数见下面的注释*/

                    yOffSet += 1;/*如果能下落 y坐标+1*/

                else {/*如不能下落 说明到底了*/

                    if (yOffSet == 0) {/*如果当前是第一个方块 游戏结束*/

                        isPlaying = 1;

                        continue;/*不再循环*/

                    }

                    freezeAndNew();/*将当前控制的方块合并到背景矩阵中 并初始化新的方块*/

                }

                repaint();/*重绘画布*/

                Thread.sleep(600);/*线程sleep 可以修改作为难度*/

            } catch (InterruptedException e) {/*无用*/

            }

    }

    private boolean check(int left, int right, int up, int down) {/*判断方块是否可以左右移动、下落、旋转 都合并到一个方法中了 四个参数分别代表要判断左移、右移、旋转、下落 如果对应方向有动作 则传入1 没有动作传入0 在判断时直接计算参数值即可 而不考虑传入的具体值是1还是0*/

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

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

                if (((xOffSet + j - left + right < 0 || xOffSet + j - left+ right >= 10) && block[blockType][((blockRotation + up) >= block[blockType].length ? 0: (blockRotation + up))][i][j] != 0)|| ((yOffSet + i + down >= 21) && block[blockType][((blockRotation + up) >= block[blockType].length ? 0: (blockRotation + up))][i][j] != 0)|| (block[blockType][((blockRotation + up) >= block[blockType].length ? 0: (blockRotation + up))][i][j] != 0 && matrix[yOffSet+ i + down][xOffSet + j - left + right] != 0))

                    return false;

        return true;

    }

    private synchronized void  freezeAndNew() {/*方块到底 固定到背景矩阵 并初始化新方块*/

        boolean[] clear = new boolean[]{false,false,false,false};/*是否可以消行的数组 每个方块4*4 只需判断方块所在的4行即可*/

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

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

                if (block[blockType][blockRotation][i][j] != 0)/*循环将方块的1赋值到背景的矩阵中 方块4*4中的0 没有方块的地方不复制*/

                    matrix[i + yOffSet][j + xOffSet] = (short) (blockColor + 1);/*根据当前方块颜色复制到背景 可修改为灰色*/

            clear[i]=i + yOffSet>=matrix.length?false:(matrix[i + yOffSet][0]!=0&&matrix[i + yOffSet][1]!=0&&matrix[i + yOffSet][2]!=0&&matrix[i + yOffSet][3]!=0&&matrix[i + yOffSet][4]!=0&&matrix[i + yOffSet][5]!=0&&matrix[i + yOffSet][6]!=0&&matrix[i + yOffSet][7]!=0&&matrix[i + yOffSet][8]!=0&&matrix[i + yOffSet][9]!=0);/*一次判断一行0~9个方块是否有值 有值 复制到消行数组为true*/

        }

        for(int i=0;i<clear.length;i++)

            if(clear[i])/*如果消行*/

                for(int j=yOffSet+i;j>0;j--)

                    System.arraycopy(matrix[j-1],0,matrix[j],0,10);/*循环从当前行依次把上面一行复制下来 下落效果*/

        yOffSet = blockRotation = 0;/*消行结束 下面几行是初始化新方块 xy方块类型 旋转 颜色*/

        xOffSet = 3;

        blockType = (short) Math.round(Math.random() * 6);

        blockRotation = (short) Math.round((Math.random() * (block[blockType].length - 1)));

        blockColor = (short) Math.round(Math.random() * 5);

    }

    public void keyPressed(KeyEvent e) {// 38-上 40-下 37-左 39-右

        if ((e.getKeyCode() == 65 || e.getKeyCode() == 37) && check(1, 0, 0, 0)&&isPlaying==0) {// left/*左移 传入判断方块是否能移动的方法 第一个参数传1 其他传0*/

            xOffSet--;/*能左移 x减1*/

        } else if ((e.getKeyCode() == 68 || e.getKeyCode() == 39)&& check(0, 1, 0, 0)&&isPlaying==0) {// right/*类似上面 右移第二个参数传1 其他0*/

            xOffSet++;/*能右移 x加1*/

        } else if ((e.getKeyCode() == 87 || e.getKeyCode() == 38)&& check(0, 0, 1, 0)&&isPlaying==0) {// up

            blockRotation = (short) ((blockRotation + 1) >= block[blockType].length ? 0: (blockRotation + 1));/*能旋转 根据当前方块类型进行旋转 如果到最后一个角度 回到0 继续旋转*/

        } else if ((e.getKeyCode() == 83 || e.getKeyCode() == 40)&& check(0, 0, 0, 1)&&isPlaying==0) {// down

                yOffSet += 1;/*能下落 y加1*/

        } else if((e.getKeyCode() == 83 || e.getKeyCode() == 40)&& isPlaying==0)

                freezeAndNew();/*不能下落 固定 并消行 新方块*/

        repaint();/*移动事件触发重绘*/

    }

    public void keyReleased(KeyEvent arg0) {/*无用*/

    }

    public void keyTyped(KeyEvent arg0) {/*无用*/

    }

}

//作者:http://wireless.javaeye.com/blog/595321

zings 2010-02-23

打赏
举报

邮箱：exe19@163.com.....

Dazzlingwinter 2010-02-23

打赏
举报

引用 38 楼 yangqi900 的回复:

我还是忍不住按了滚动条。。。

哈哈，我是直接诶ctrl+d倒着看的~

深山老叔 2010-02-23

打赏
举报

我还是忍不住按了滚动条。。。

james2222 2010-02-21

打赏
举报

testing

Z_FEI 2010-02-21

打赏
举报

好复杂啊，谢谢lz分享，O(∩_∩)O~

haffy 2010-02-21

打赏
举报

好东西啊！！！！！！！

java1109 2010-02-21

打赏
举报

谢谢分享！！！

xuexi100 2010-02-21

打赏
举报

MatrixModel文件2



/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package lesson54;



import java.util.*;



/**

 *

 * @author scj

 */

public class MatrixModel {



    private int model[][];

    private int sharp[][];

    private int state[][];

    private int currentX, currentY;

    private Matrix myParent;

    private RunThread runThread;

    private int currentIndex;



    public MatrixModel(Matrix parent) {

        myParent = parent;

        model = new int[Matrix.ROW][Matrix.COLUMN];

        state = new int[Matrix.ROW][Matrix.COLUMN];

        newSharp();

    }



    public void start() {

        runThread = new RunThread();

        runThread.start();

    }



    private int[][] randomSharp() {

        currentIndex = (int) (MatrixSharp.NUMBER * Math.random());

        return MatrixSharp.sharp[currentIndex];

    }



    private synchronized boolean isMoveAvaliable(int currentX, int currentY) {

        if (currentX > Matrix.COLUMN - 1) {

            return false;

        }

        if (currentX < 0) {

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

                for (int j = 0; j < Math.abs(currentX); j++) {

                    if (sharp[i][j] != 0) {

                        return false;

                    }

                }

            }

        }

        if (currentY < 0 || currentY > Matrix.ROW - 1) {

            return false;

        }

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

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

                if (currentX + x > -1 && currentX + x < Matrix.COLUMN && currentY + y < Matrix.ROW) {

                    if ((sharp[y][x] & model[currentY + y][currentX + x]) != 0) {

                        return false;

                    }

                } else {

                    if (currentX + x >= Matrix.COLUMN) {

                        if (sharp[y][x] != 0) {

                            return false;

                        }

                    } else if (currentY + y >= Matrix.ROW) {

                        if (sharp[y][x] != 0) {

                            return false;

                        }

                    }

                }

            }

        }

        return true;

    }



    private synchronized void moveTo(int x, int y) {

        for (int i = 0; i < Matrix.ROW; i++) {

            for (int j = 0; j < Matrix.COLUMN; j++) {

                state[i][j] = model[i][j];

            }

        }

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

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

                if (currentX + c > -1 && currentX + c < Matrix.COLUMN && currentY + r < Matrix.ROW) {

                    state[currentY + r][currentX + c] |= sharp[r][c];

                }

            }

        }

        myParent.displayState(state);

    }



    public void over() {

        System.out.println("game over");

        runThread.end();

    }



    public synchronized void moveLeft() {

        if (isMoveAvaliable(currentX - 1, currentY)) {

            currentX -= 1;

            moveTo(currentX, currentY);

        }

    }



    public synchronized void moveRight() {

        if (isMoveAvaliable(currentX + 1, currentY)) {

            currentX += 1;

            moveTo(currentX, currentY);

        }

    }



    private boolean isOver() {

        if (currentY == 0) {

            return false;

        }

        return false;

    }



    private synchronized void resetState() {

        state = new int[Matrix.ROW][Matrix.COLUMN];

        moveTo(currentX, currentY);

    }



    public synchronized void down() {

        if (isMoveAvaliable(currentX, currentY + 1)) {

            currentY += 1;

            moveTo(currentX, currentY);

        } else {

            if (isOver()) {

                over();

                return;

            }

            model = state;

            check();

            resetState();

            newSharp();

        }

    }



    public synchronized void check() {

        Vector clearVector = new Vector();

        for (int i = Matrix.ROW - 1; i > 0; i--) {

            int j = 0;

            for (; j < Matrix.COLUMN; j++) {

                if (model[i][j] == 0) {

                    break;

                }

            }

            if (j == Matrix.COLUMN) {

                clearVector.add(new Integer(i));

            }

        }

        clearRows(clearVector);

    }



    private synchronized void clearRows(Vector clearVector) {



        for (int i = clearVector.size(); i > 0; i--) {

            int row = ((Integer) clearVector.get(i - 1)).intValue();

            for (int j = 0; j < Matrix.COLUMN; j++) {

                for (int k = row; k >= 0; k--) {

                    if (k == 0) {

                        model[k][j] = 0;

                    } else {

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

                    }

                }

            }

        }

    }



    public synchronized void rotateSharp() {

        int tmpIndex = currentIndex++;

        if (currentIndex % 4 == 0) {

            currentIndex -= 4;

        }

        int[][] tmpSharp = MatrixSharp.sharp[currentIndex];

        if (isRotateAble(tmpSharp)) {

            sharp = MatrixSharp.sharp[currentIndex];

            moveTo(currentX, currentY);

        } else {

            currentIndex = tmpIndex;

        }

    }



    private synchronized boolean isRotateAble(int sharp[][]) {

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

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

                if ((currentX + x < 0 || currentX + x >= Matrix.COLUMN) || (currentY + y < 0 || currentY + y >= Matrix.ROW)) {

                    if (sharp[y][x] != 0) {

                        return false;

                    }

                }

            }

        }

        return isMoveAvaliable(currentX, currentY);

    }



    private synchronized void newSharp() {

        currentX = Matrix.COLUMN / 2;

        currentY = 0;

        sharp = randomSharp();

    }



    class RunThread extends Thread {



        boolean isRun = true;



        public void end() {

            isRun = false;

        }



        public void run() {

            while (isRun) {

                down();

                try {

                    sleep(500);

                } catch (Exception e) {

                    e.printStackTrace();

                }

            }

        }

    }

}



interface MatrixSharp {



    static int sharp[][][] = new int[][][]{

        {{0, 0, 1, 0}, {0, 0, 1, 0}, {0, 1, 1, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {0, 1, 0, 0}, {0, 1, 1, 1}, {0, 0, 0, 0}},

        {{0, 1, 1, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {1, 1, 1, 0}, {0, 0, 1, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {0, 1, 1, 0}, {0, 1, 1, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {0, 1, 1, 0}, {0, 1, 1, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {0, 1, 1, 0}, {0, 1, 1, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {0, 1, 1, 0}, {0, 1, 1, 0}, {0, 0, 0, 0}},

        {{1, 1, 1, 1}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},

        {{0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 0, 0}},

        {{1, 1, 1, 1}, {0, 0, 0, 0}, {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, 1, 1, 0}, {0, 0, 1, 1}, {0, 0, 0, 0}},

        {{0, 0, 1, 0}, {0, 1, 1, 0}, {0, 1, 0, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {0, 1, 1, 0}, {0, 0, 1, 1}, {0, 0, 0, 0}},

        {{0, 0, 1, 0}, {0, 1, 1, 0}, {0, 1, 0, 0}, {0, 0, 0, 0}},

        {{0, 0, 1, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},

        {{0, 0, 1, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},

        {{0, 0, 1, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},

        {{0, 0, 1, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}},

        {{0, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 1, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {0, 0, 1, 0}, {1, 1, 1, 0}, {0, 0, 0, 0}},

        {{0, 1, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 0}, {0, 0, 0, 0}},

        {{0, 0, 0, 0}, {0, 1, 1, 1}, {0, 1, 0, 0}, {0, 0, 0, 0}}};

    static int NUMBER = sharp.length;

}

xuexi100 2010-02-21

打赏
举报

Matrix.java 文件1;



/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package lesson54;



import java.awt.Color;

import java.awt.Dimension;

import java.awt.GridLayout;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;



import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.border.LineBorder;



/**

 *

 * @author scj

 */

/**

 * 运行该文件

 */

public class Matrix extends JPanel {



    private JLabel matrix[][];

    public static final int ROW = 20;

    public static final int COLUMN = 15;

    private MatrixModel model;



    public Matrix() {

        this.setLayout(new GridLayout(ROW, COLUMN));

        init();

        Dimension size = new Dimension(COLUMN * 20, ROW * 20);

        this.setPreferredSize(size);

        this.setMinimumSize(size);

        this.setMaximumSize(size);

        this.addKeyListener(new MyKeyListener());

        this.setFocusable(true);

        model = new MatrixModel(this);

    }



    public void start() {

        model.start();

    }



    private void init() {

        matrix = new JLabel[ROW][COLUMN];

        JLabel label = null;

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

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

                label = new JLabel(" ");

                label.setBorder(new LineBorder(Color.GRAY));

                label.setOpaque(true);

                matrix[i][j] = label;

                add(matrix[i][j]);

            }

        }

    }



    public void displayState(int[][] state) {

        for (int i = 0; i < state.length; i++) {

            for (int j = 0; j < state[i].length; j++) {

                if (state[i][j] == 1) {

                    matrix[i][j].setBackground(Color.red);

                } else {

                    matrix[i][j].setBackground(Color.black);

                }

            }

        }

    }



    class MyKeyListener extends KeyAdapter {



        public void keyPressed(KeyEvent e) {

            if (e.getKeyCode() == KeyEvent.VK_LEFT) {

                model.moveLeft();

            } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {

                model.moveRight();

            } else if (e.getKeyCode() == KeyEvent.VK_DOWN) {

                model.down();

            } else if (e.getKeyCode() == KeyEvent.VK_UP) {

                model.rotateSharp();

            }

        }

    }



    public static void main(String arg[]) {

        JFrame frame = new JFrame();

        Matrix matrix = new Matrix();

        matrix.start();

        frame.add(new JScrollPane(matrix));

        frame.pack();

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        frame.setVisible(true);

        /*

         * int i[][] = {{10,20}, {11, 21}, {21, 31}}; int j[][] = new int[3][2];

         * System.arraycopy(i, 0, j, 0, i.length); for(int x=0; x<j.length;

         * x++){ for(int y=0; y<j[x].length; y++){ System.out.print(j[x][y]+"

         * "); } System.out.println(); }

         */

    }

}