`
yaerfeng1989
  • 浏览: 232767 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

同样分享一个网友的俄罗斯方块

阅读更多

感觉写的挺好的,所以分享到最代码上来,如果有版权问题我会尽快删除,看截图

原创整理不易,请注明出处:同样分享一个网友的俄罗斯方块

swing的main类如下:

package com.zuidaima.swing.game

import sun.audio.*;
import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
import javax.swing.*;
/**
* Description:a simple tetric game
* <br/>Program Name:Tetric Game
* <br/>Date:2012.08.24
* @author  Garth   http://xiaojia.me
* @version  1.0
*/
@SuppressWarnings("serial")
public class TetricGame extends JFrame{
    
    public static void main(String[] args){
        final TetricBlock tetricBlock = new TetricBlock();
        final TetricGame tetricGame = new TetricGame();
        
        //工具栏按钮动作
        Action startAction = new AbstractAction("start" , 
                new ImageIcon(TetricGame.class.getClassLoader().getResource("res/start.png"))) {
            public void actionPerformed(ActionEvent e) {
                tetricBlock.setIsGaming(true);
                tetricGame.requestFocus();
            }
        };
        Action pauseAction = new AbstractAction("pause" , 
                new ImageIcon(TetricGame.class.getClassLoader().getResource("res/pause.png"))) {
            public void actionPerformed(ActionEvent a) {
                tetricBlock.setIsGaming(false);
                tetricGame.requestFocus();
            }
        };
        Action aboutAction = new AbstractAction("about" , 
                new ImageIcon(TetricGame.class.getClassLoader().getResource("res/about.png"))) {
            public void actionPerformed(ActionEvent e) {
                tetricBlock.setIsGaming(false);
                JOptionPane.showMessageDialog(null , "Java新手练习项目:俄罗斯方块\n" +
                		"作者:Garth\n" +
                        "博客:http://xiaojia.me");
                tetricBlock.setIsGaming(true);
                tetricGame.requestFocus();
            }
        };
        Action closeAction = new AbstractAction("close" , 
                new ImageIcon(TetricGame.class.getClassLoader().getResource("res/close.png"))) {
            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        };
        JToolBar jtb = new JToolBar();
        //工具栏垂直并不可拖动
        jtb.setOrientation(JToolBar.VERTICAL);
        jtb.setFloatable(false);
        jtb.add(startAction);
        jtb.add(pauseAction);
        jtb.add(aboutAction);
        jtb.add(closeAction);
        
        tetricGame.add(jtb , BorderLayout.EAST);
        tetricGame.add(tetricBlock);
        tetricGame.addKeyListener(tetricBlock);
        tetricGame.setSize( 323 , 474);
        tetricGame.setLocationRelativeTo(null);
        tetricGame.setTitle("俄罗斯方块");
        tetricGame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        tetricGame.setVisible(true);
        //必不可少的一句,让主窗口获得焦点以监听键盘
        tetricGame.requestFocus();
    }
}

//方块类,继承JPanel类,实现KeyListener接口
@SuppressWarnings("serial")
class TetricBlock extends JPanel  implements KeyListener{
    
    //游戏得分
    private int score = 0;
    //方块下落的时间触发器
    private Timer timer;
    //方块下落速度值,值越小,速度越快
    private int speed = 1000;
    //游戏状态
    private boolean isGaming = true;
    //背景音乐
    private MusicPlayer bkMusic;
    //正在移动的方块坐标
    private int x , y;
    //方块类型与状态
    private int blockType , blockState;
    private int i = 0 , j = 0;
    //已经下落固定的方块map,0-11 ,0-21
    private int[][] map = new int[13][23];
    //方块,一维代表类型,二维代表状态,三维代表组成方块矩阵
    private final int[][][] block = new int[][][] {
            {   //一横一竖
                { 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 }
            },
            {   //S型
                { 0,0,1,1 , 0,1,1,0 , 0,0,0,0 , 0,0,0,0 },
                { 1,0,0,0 , 1,1,0,0 , 0,1,0,0 , 0,0,0,0 },
                { 0,0,1,1 , 0,1,1,0 , 0,0,0,0 , 0,0,0,0 },
                { 1,0,0,0 , 1,1,0,0 , 0,1,0,0 , 0,0,0,0 }
            },
            {   //Z型
                { 1,1,0,0 , 0,1,1,0 , 0,0,0,0 , 0,0,0,0 },
                { 0,1,0,0 , 1,1,0,0 , 1,0,0,0 , 0,0,0,0 },
                { 1,1,0,0 , 0,1,1,0 , 0,0,0,0 , 0,0,0,0 },
                { 0,1,0,0 , 1,1,0,0 , 1,0,0,0 , 0,0,0,0 }
            },
            {   //J型
                { 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 },
                { 1,1,0,0 , 1,0,0,0 , 1,0,0,0 , 0,0,0,0 },
                { 1,1,1,0 , 0,0,1,0 , 0,0,0,0 , 0,0,0,0 }
            },
            {   //L型
                { 1,0,0,0 , 1,0,0,0 , 1,1,0,0 , 0,0,0,0 },
                { 0,0,1,0 , 1,1,1,0 , 0,0,0,0 , 0,0,0,0 },
                { 1,1,0,0 , 0,1,0,0 , 0,1,0,0 , 0,0,0,0 },
                { 1,1,1,0 , 1,0,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,0 , 0,0,0,0 }
            },
            {   //T型
                { 1,1,1,0 , 0,1,0,0 , 0,0,0,0 , 0,0,0,0 },
                { 0,1,0,0 , 1,1,0,0 , 0,1,0,0 , 0,0,0,0 },
                { 0,1,0,0 , 1,1,1,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 }
            }
    };
    
    public TetricBlock() {
      
        newBlock();
        newMap();
        drawWall();
        timer = new Timer( speed , new TimerListener() );
        timer.start();
    }

    //设置游戏状态
    public void setIsGaming(boolean is) {
        isGaming = is;
    }
    //画围墙
    public void drawWall(){
        
        //底部围墙
        for(i = 0 ; i < 12 ; i ++) {
            map[i][21] = 2;
        }
        //两边的围墙
        for(i = 0 ; i < 22 ; i++) {
            map[0][i] = 2;
            map[11][i] = 2;
        }
    }

    //初始化数组
    public void newMap(){
        
        for(i = 0 ; i < 12 ; i++) {
            for(j = 0 ; j < 22 ; j++) {
                map[i][j] = 0;
            }
        }
      //循环播放背景音乐
        try {
            bkMusic = new MusicPlayer(TetricGame.class.getClassLoader().getResource("res/background.wav"));
            bkMusic.loop();
        }
        catch(Exception e) {
        }
    }

    //产生新的方块
    public void newBlock(){
        
        blockType = (int) (( Math.random() * 1000 ) % 7 );
        blockState = (int) (( Math.random() * 1000) % 4 );
        x = 4;
        y = 0;
        if(gameOver(x , y)){
            JOptionPane.showMessageDialog(null, "Game Over! Score: " + score);
            newMap();
            drawWall();
            score = 0;
            speed = 1000;
            timer.setDelay(speed);
            isGaming = true;
        }
    }
    
    //判断移动方块是否合法
    public boolean canMove( int x , int y , int blockType , int blockState ) {
        
        for( i = 0 ; i < 4 ; i++)
            for( j = 0 ; j < 4 ; j++) 
                if(( block[blockType][blockState][ i * 4 + j ] == 1 &&
                        map[ j + x + 1][ i + y ] == 1 ) ||
                        ( block[blockType][blockState][ i * 4 + j ] == 1 &&
                        map[ j + x + 1][ i + y ] == 2 )) 
                    return false;
        return true;
    }
    
    //判断游戏是否结束
    public boolean gameOver( int x , int y ) {
        
        if( !canMove( x , y , blockType , blockState ) ) {
            isGaming = false;
            //播放音乐
            try {
                bkMusic.stopLoop();
                new MusicPlayer(TetricGame.class.getClassLoader().getResource("res/gameover.wav")).start();
            }
            catch(Exception e) {
            }
            return true;
        }
        return false;
    }
    
    //方块左移
    public void moveLeft() {
        
        if( isGaming && canMove( x - 1 , y , blockType , blockState ))
            x--;
        repaint();
    }
    
    //方块向右移
    public void moveRight() {
        
        if( isGaming && canMove( x + 1 , y , blockType , blockState ))
            x++;
        repaint();
    }
    
    //方块向下移
    public void moveDown() {
        
        if( isGaming ) {
            if( canMove( x , y + 1 , blockType , blockState) ) {
                y++;
                dellLine();
            }
            else {
                addBlock( x , y , blockType , blockState );
                dellLine();
                newBlock();
            }
            repaint();
        }
    }
    
    //改变方块状态
    public void turnState() {
        if( isGaming ) {
            int tempState = blockState;
            blockState = ( blockState + 1 ) % 4;
            if( !canMove( x , y , blockType , blockState ) )
                blockState = tempState;
            repaint();
        }
    }
    
    //把不能再继续下落的方块加到固定方块里
    public void addBlock( int x , int y , int blockType , int blockState ) {
        
        try {
            new MusicPlayer(TetricGame.class.getClassLoader().getResource("res/addblock.wav")).start();
        }
        catch(Exception e){
        }
        int k = 0;
        for( i = 0 ; i < 4 ; i++){
            for( j = 0 ; j < 4 ; j++) {
                if(map[ j + x + 1 ][ i + y ] == 0) {
                    map[ j + x + 1 ][ i + y ] = block[blockType][blockState][k];
                }
                k++;
            }
        }
    }
    
    //消行
    public void dellLine() {
        int k = 0;
        for( i = 0 ; i < 22 ; i++ ) {
            for( j = 0 ; j < 12 ; j++ ) {
                if( map[j][i] == 1) {
                    k++;
                    if( k >= 10 ) {
                        //播放声音
                        try {
                            new MusicPlayer(TetricGame.class.getClassLoader().getResource("res/delline.wav")).start();
                        }
                        catch(Exception e) {
                        }
                        //游戏分数添加分数
                        score += 10;
                        //速度越来越快
                        speed -= 15;
                        timer.setDelay( speed );
                        //消行后,把上面固定的方块下移
                        for( int a = i ; a > 0 ; a--) 
                            for( int b = 0 ; b < 11 ; b++ ) {
                                map[b][a] = map[b][a - 1];
                            }
                    }
                }
            }
            k = 0;
        }
        repaint();
    }
    
    public void paintComponent(Graphics g) {
        
        super.paintComponent(g);
        //方块图像
        Image blockImage = null;
        try{
            blockImage = ImageIO.read(TetricGame.class.getClassLoader().getResource("res/block.png"));
        }
        catch (IOException e){
            e.printStackTrace();
        }
        //正在下落的方块
        for(i = 0 ; i < 16 ; i++) {
            if( block[blockType][blockState][i] == 1 ) {
                g.drawImage(blockImage, ((i % 4) + x + 1) * 20 , ((i / 4) + y) * 20,20,20 ,null);
            }
        }
        
        //已经下落的固定的方块以及围墙
        for(i = 0 ; i < 22 ; i++)
            for(j = 0 ; j < 12 ; j++) {
                if(map[j][i] == 1)
                    g.drawImage(blockImage , j * 20 , i * 20 , 20 , 20 , null);
                
                if(map[j][i] == 2) {
                    g.setColor(new Color(9 , 106 , 187));
                    g.fillRect(j * 20 , i * 20 , 20 , 20);
                }
            }
    }
    
    //监听键盘上下左右方向键
    public void keyPressed(KeyEvent e){
        switch( e.getKeyCode() ) {
            case KeyEvent.VK_UP:
                turnState();
                break;
            case KeyEvent.VK_DOWN:
                moveDown();
                break;
            case KeyEvent.VK_LEFT:
                moveLeft();
                break;
            case KeyEvent.VK_RIGHT:
                moveRight();
                break;
        }
    }

    public void keyReleased(KeyEvent arg0){
    }

    public void keyTyped(KeyEvent arg0){
    }
    
    //内部类,时间监听器
    class TimerListener implements ActionListener{

        public void actionPerformed(ActionEvent e){
            repaint();
            moveDown();
        }
    }
    
    //内部类,音乐播放器
    class MusicPlayer{
        //单次播放的声音
        private AudioStream as = null;
        //循环播放的声音
        private ContinuousAudioDataStream cas = null;
        
        public MusicPlayer(URL url) {
            try {
                as = new AudioStream(url.openStream());
            }
            catch(Exception e) {
                
            }
        }
        //播放单次声音
        public void start() {
            if(as != null) {
                AudioPlayer.player.start(as);
            }
        }
        //停止单次播放的声音
        public void stop() {
            if(as != null) {
                AudioPlayer.player.stop(as);
            }
        }
        //循环播放声音
        public void loop() {
            AudioData data = null;
            try {
                data = as.getData();
            }
            catch(Exception e) {
                
            }
            if(data != null) {
                cas = new ContinuousAudioDataStream(data);
                AudioPlayer.player.start(cas);
            }
            
        }
        //停止循环播放的声音
        public void stopLoop() {
            if(cas != null) {
                AudioPlayer.player.stop(cas);
            }
        }
    }
}

	    			

 完整代码下载:http://www.zuidaima.com/share/1550463376362496.htm

 

0
0
分享到:
评论

相关推荐

    用java写的一个俄罗斯方块的游戏

    在编程领域,创建一个经典游戏如俄罗斯方块是一种常见的学习实践,可以加深对编程语言特性和面向对象设计的理解。在这个案例中,我们看到一个用Java实现的俄罗斯方块游戏。Java作为一种广泛使用的、跨平台的编程语言...

    python基于pygame的俄罗斯方块小游戏源码.zip

    python基于pygame的俄罗斯方块小游戏源码。python基于pygame的俄罗斯方块小游戏源码。python基于pygame的俄罗斯方块小游戏源码。python基于pygame的俄罗斯方块小游戏源码。python基于pygame的俄罗斯方块小游戏源码。...

    俄罗斯方块(C语言版) 俄罗斯方块

    【俄罗斯方块(C语言版) 俄罗斯方块】是一个基于C语言实现的经典游戏项目,它将编程技术与游戏设计巧妙结合,展示了C语言在创建交互式程序方面的潜力。在这个项目中,开发者利用C语言的基本结构,如循环、条件语句...

    学习的一个HTML俄罗斯方块游戏.zip

    学习的一个HTML俄罗斯方块游戏.zip学习的一个HTML俄罗斯方块游戏.zip 学习的一个HTML俄罗斯方块游戏.zip学习的一个HTML俄罗斯方块游戏.zip 学习的一个HTML俄罗斯方块游戏.zip学习的一个HTML俄罗斯方块游戏.zip 学习...

    俄罗斯方块 c# 俄罗斯方块

    顶下俄罗斯方块 c#俄罗斯方块 c#俄罗斯方块 c#顶下俄罗斯方块 c#俄罗斯方块 c#俄罗斯方块 c#顶下俄罗斯方块 c#俄罗斯方块 c#俄罗斯方块 c#顶下俄罗斯方块 c#俄罗斯方块 c#俄罗斯方块 c#

    俄罗斯方块 俄罗斯方块.rar

    "使用方法.url"则是一个链接,可能指向了详细的《俄罗斯方块》操作指南,帮助新玩家快速上手。"Images"目录很可能包含了游戏截图、方块图形或者其他相关图片资料,这些视觉元素有助于理解游戏的外观和设计。 ...

    c语言俄罗斯方块完整源码

    c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言俄罗斯方块完整源码 c语言...

    俄罗斯方块C语言报告

    - **随机产生俄罗斯方块类型的序号**:生成一个随机数来决定下一个方块的类型。 - **打印俄罗斯方块**:将当前方块显示在屏幕上。 - **清除俄罗斯方块的痕迹**:当方块移动或旋转时,清除原来位置的图形。 - **判断...

    C#俄罗斯方块(winform)

    C#俄罗斯方块(winform)C#俄罗斯方块(winform)C#俄罗斯方块(winform)C#俄罗斯方块(winform)C#俄罗斯方块(winform)C#俄罗斯方块(winform)C#俄罗斯方块(winform)

    一个n年前用vb写的俄罗斯方块游戏源代码

    【标题】中的“一个n年前用vb写的俄罗斯方块游戏源代码”表明这是一个基于Visual Basic(VB)编程语言开发的俄罗斯方块游戏的源代码。VB是微软公司开发的一种面向对象的编程语言,尤其在20世纪90年代至21世纪初非常...

    俄罗斯方块C++源代码

    在编程领域,经典游戏俄罗斯方块是一个极好的学习案例,它涉及到了基础的图形界面设计、事件处理、数据结构和算法等多个知识点。本篇文章将对“俄罗斯方块C++源代码”进行深入剖析,帮助读者理解并学习其中的关键...

    java编的俄罗斯方块

    好游戏java编的俄罗斯方块好游戏java编的俄罗斯方块好游戏java编的俄罗斯方块好游戏java编的俄罗斯方块好游戏java编的俄罗斯方块好游戏java编的俄罗斯方块好游戏java编的俄罗斯方块好游戏java编的俄罗斯方块好游戏...

    俄罗斯方块 俄罗斯方块

    这款由苏联程序员阿列克谢·帕基特诺夫设计的游戏,以其简洁的图形、易于理解和深度的策略性,成为了电子游戏历史上的一个里程碑。 游戏的基本概念是控制各种形状(通常由四个单位方块组成)的“方块”下落,并在...

    PSP俄罗斯方块.iso

    PSP俄罗斯方块.iso

    VC可视化俄罗斯方块源码

    之前我是玩过俄罗斯方块的,一种是单人的(单人版),一种是两人对战的(对战版),还有一种是网络版的,由于我还不了解网络,所以就决定编前两种。可是,这样没有新意,我就想到了另外一种,配合游戏,或者称为情侣...

    SCRATCH版3D俄罗斯方块

    使用SCRATCH开发的3D版俄罗斯方块

    基于强化学习的AI俄罗斯方块

    基于强化学习的AI俄罗斯方块基于强化学习的AI俄罗斯方块基于强化学习的AI俄罗斯方块基于强化学习的AI俄罗斯方块基于强化学习的AI俄罗斯方块基于强化学习的AI俄罗斯方块基于强化学习的AI俄罗斯方块基于强化学习的AI...

    flash俄罗斯方块源代码

    4. **时间管理**:为了保持游戏的节奏感,开发者通常会设定一个定时器(`Timer`类)来控制方块的自动下落速度。定时器的触发事件会调用下落函数,随着游戏进行,定时器间隔可适当调整以增加难度。 5. **碰撞检测**...

    MFC编写的俄罗斯方块

    总之,MFC为构建俄罗斯方块游戏提供了一个结构化的开发环境,通过它的类库和消息处理机制,开发者可以专注于游戏的逻辑和设计,而无需过多关注底层的Windows编程细节。尽管MFC在现代软件开发中可能不如其他框架流行...

    有自动游戏功能的俄罗斯方块

    在这个俄罗斯方块游戏中,wxWidgets被用来创建用户友好的界面,包括游戏窗口、按钮、计分板等元素,使得游戏在不同平台上保持一致的用户体验。 mingw(Minimalist GNU for Windows)是一个GNU工具集,为Windows平台...

Global site tag (gtag.js) - Google Analytics