java小游戏第一弹 简易俄罗斯

最新推荐文章于 2023-10-31 18:01:53 发布
最新推荐文章于 2023-10-31 18:01:53 发布
阅读量8k 收藏 29
点赞数 4
分类专栏： java简易小游戏 文章标签： java java课程设计 俄罗斯方块 Tag
/*
 * 俄罗斯方块是一个经典的游戏。本版只是简易制作
 * 思想：俄罗斯方块分层处理
 * (表现层)一个int[][] map数组来展示n*m的方格，有方块的为1,一次遍历数组，画出方块
 * (数据层)int[][][][] shapes数组用01来区分方块形状
 * (控制层)int x，y记录下落方块位置，通过shapes[][][i][j]&map[x+i][y+j]的结果来判断是否碰撞而进行一系列操作

 */


package cn.hncu.games;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.Random;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
import javax.swing.Timer;

public class Tetris extends JFrame{
	
	private nextBlockJPanel p;
	private TetrisPanel a; 
	private int set_delay=1000;

	private JMenu[] jmenu;
	private JMenuItem[][] jmenuItem;
	/*
	 * 动态监听菜单
	 */
	private ActionListener jmenuListener=new ActionListener() {
		
		@Override
		public void actionPerformed(ActionEvent e) {
			if(e.getActionCommand().equals("newGame")){
				a.newGame();
				jmenuItem[0][2].setEnabled(false);
				jmenuItem[0][1].setEnabled(true);
				for (int i = 0; i < jmenuItem[1].length; i++) {
					jmenuItem[1][i].setEnabled(false);
				}
				for (int i = 0; i < jmenuItem[2].length; i++) {
					jmenuItem[2][i].setEnabled(false);
				}
			}else if(e.getActionCommand().equals("break")){
				if(a.timer!=null)
					a.timer.stop();
				jmenuItem[0][1].setEnabled(false);
				jmenuItem[0][2].setEnabled(true);
				for (int i = 0; i < jmenuItem[1].length; i++) {
					jmenuItem[1][i].setEnabled(true);
				}
			}else if(e.getActionCommand().equals("continue")){
				if(a.timer!=null)
					a.timer.restart();
				jmenuItem[0][2].setEnabled(false);
				jmenuItem[0][1].setEnabled(true);
				for (int i = 0; i < jmenuItem[1].length; i++) {
					jmenuItem[1][i].setEnabled(false);
				}
				p.score=p.now_score;
				for (int i = 0; i < a.map.length; i++) {
					for (int j = 0; j < a.map[i].length; j++) {
						a.map[i][j]=a.now_map[i][j];
					}
				}
				a.repaint();
				p.repaint();
			}else if(e.getActionCommand().equals("exit")){
				if (a.timer!=null&&a.timer.isRunning()) {
					a.timer.stop();
				}
				//System.exit(0);
				dispose();
			}else if(e.getActionCommand().equals("last_score")){
				if(a.timer!=null)
					a.timer.stop();
				p.score=p.last_score;
				for (int i = 0; i < a.map.length; i++) {
					for (int j = 0; j < a.map[i].length; j++) {
						a.map[i][j]=a.last_map[i][j];
					}
				}
				a.repaint();
				p.repaint();
			}else if(e.getActionCommand().equals("optimal_score")){
				if(a.timer!=null)
					a.timer.stop();
				p.score=p.optimal_score;
				for (int i = 0; i < a.map.length; i++) {
					for (int j = 0; j < a.map[i].length; j++) {
						a.map[i][j]=a.optimal_map[i][j];
					}
				}
				a.repaint();
				p.repaint();
			}else if(e.getActionCommand().equals("hard")){
				set_delay=200;
			}else if(e.getActionCommand().equals("middle")){
				set_delay=600;
			}else if(e.getActionCommand().equals("low")){
				set_delay=1000;
			}
			
		}
	};
	/*
	 * 俄罗斯方块形状
	 */
	private int[][][][] shapes=new int[][][][]{
			//T
			{{         {0,1,0}, {1,1,1}},
			 {{0,0,1}, {0,1,1}, {0,0,1}},
			 {{1,1,1}, {0,1,0}         },
			 {{1,0,0}, {1,1,0}, {1,0,0}}},
			//L
			{{{0,1,0}, {0,1,0}, {0,1,1}},
			 {{0,0,1}, {1,1,1}},
			 {{1,1,0}, {0,1,0}, {0,1,0}},
			 {         {1,1,1}, {1,0,0}}},
			//J
			{{{0,1,0}, {0,1,0}, {1,1,0}},
			 {         {1,1,1}, {0,0,1}},
			 {{0,1,1}, {0,1,0}, {0,1,0}},
			 {{1,0,0}, {1,1,1}        }},
			//S
			{{{0,1,1}, {1,1,0}         },
			 {{0,1,0}, {0,1,1}, {0,0,1}}},
			 //Z
			{{{1,1,0}, {0,1,1}         },
			 {{0,1,0}, {1,1,0}, {1,0,0}}},
			 //O
			{{{1,1}, {1,1}}},
			//I
			{{{1,1,1,1}         },
			 {{1}, {1}, {1}, {1}}}
	};
	
	public Tetris() {
		super("俄罗斯方块简易版");
		setBounds(200, 100, 700, 600);
		setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		//getContentPane().setLayout(new BorderLayout());
		
		//菜单
		JMenuBar bar=new JMenuBar();
		//for添加一系列菜单,
		String[] str={"选项","记录","难度"};
		String[][] strs={{"新游戏","暂停","继续","退出"},
				         {"上轮成绩","最佳成绩"},
				         {"难","中","低"}};
		String[][] strs_english={{"newGame","break","continue","exit"},
				{"last_score","optimal_score"},
				{"hard","middle","low"}};
		jmenu=new JMenu[str.length];
		jmenuItem=new JMenuItem[strs.length][];
		for (int i = 0; i < jmenu.length; i++) {
			jmenu[i]=new JMenu(str[i]);
			jmenuItem[i]=new JMenuItem[strs[i].length];
			for (int j = 0; j < jmenuItem[i].length; j++) {
				jmenuItem[i][j]=new JMenuItem(strs[i][j]);
				jmenuItem[i][j].addActionListener(jmenuListener);
				jmenuItem[i][j].setActionCommand(strs_english[i][j]);
				if(jmenuItem[i][j].getActionCommand().equals("continue"))
					jmenuItem[i][j].setEnabled(false);
				if(jmenuItem[i][j].getActionCommand().equals("break"))
					jmenuItem[i][j].setEnabled(false);
				jmenu[i].add(jmenuItem[i][j]);
			}
			bar.add(jmenu[i]);
		}
		setJMenuBar(bar);
		
		//记分面板
		p=new nextBlockJPanel();
		//游戏绘画面板
		a = new TetrisPanel(p);
		addKeyListener(a.timerListeren);
		JSplitPane sp=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,a,p);
		sp.setDividerLocation(400);
		getContentPane().add(sp);
		
		
		setVisible(true);
	}

	public class TetrisPanel extends JPanel{
		private nextBlockJPanel p;
		
		private int blockType; 
		private int turnState;
		
		private int local_x;
		private int local_y;
		
		private int delay;
		private TimerListeren timerListeren=new TimerListeren();
		
		private Timer timer;
	
		
		private int[][] map=new int[27][20];
		private int[][] now_map=new int[27][20];
		private int[][] last_map=new int[27][20];
		private int[][] optimal_map=new int[27][20];
	
		/*
		 * 构造函数并map初始化，构造墙壁
		 */
		public TetrisPanel(nextBlockJPanel p){
			this.p=p;
			for (int i = 0; i <map.length; i++) {
				for (int j = 0; j <map[i].length; j++) {
					if(j==0||j==map[i].length-1||i==map.length-1){
						map[i][j]=3;
					}else{
						map[i][j]=0;
					}
				}
			
			}
		}

		/*
		 * 游戏开始
		 */
		private void newGame() {
			for (int i = 0; i <map.length; i++) {
				for (int j = 0; j <map[i].length; j++) {
					if(j==0||j==map[i].length-1||i==map.length-1){
						map[i][j]=3;
					}else{
						map[i][j]=0;
					}
				}
			
			}

			nextBlock();
			p.score=0;
			for (int i = 0; i < map.length; i++) {
				for (int j = 0; j < map[i].length; j++) {
					now_map[i][j]=map[i][j];
				}
			}
			p.now_score=p.score;
			delay=set_delay;
			timer=new Timer(delay, timerListeren);
			timer.start();
		}

		/*
		 * 下一方块形状
		 */
		private void nextBlock() {
			blockType=p.blockType;
			turnState=p.turnState;
			local_x=8;
			local_y=0;
			p.nextBlock();
			repaint();
			isGameOver();
		}
		//下落
		private void down(){
			if(crash(blockType,turnState,local_x,local_y+1)==1){
				local_y++;
			}else{
				add(blockType,turnState,local_x,local_y);
				nextBlock();
				
			}
			repaint();
		}
		//键盘方向键操作
		private void left() {
			local_x-=crash(blockType, turnState, local_x-1, local_y);
			repaint();
			
		}

		private void right() {
			local_x+=crash(blockType, turnState, local_x+1, local_y);
			repaint();
		}

		private void trun() {
			turnState=(turnState+crash(blockType, (turnState+1)%shapes[blockType].length, local_x, local_y))%shapes[blockType].length;
			repaint();
		}
		//加方块
		private void add(int blockType, int turnState, int local_x,int local_y) {
			for (int i = 0; i < shapes[blockType][turnState].length; i++) {
				for (int j = 0; j < shapes[blockType][turnState][i].length; j++) {
					if(shapes[blockType][turnState][i][j]!=0)
						map[local_y+i][local_x+j]=shapes[blockType][turnState][i][j];
				}
			}
			Deline();
			for (int i = 0; i < map.length; i++) {
				for (int j = 0; j < map[i].length; j++) {
					now_map[i][j]=map[i][j];
				}
			}
			p.now_score=p.score;
		}
		//是否游戏结束
        private void isGameOver() {
			if(crash(blockType, turnState, local_x, local_y)==0){
				p.last_score=p.score;
				for (int i = 0; i < map.length; i++) {
					for (int j = 0; j < map[i].length; j++) {
						last_map[i][j]=map[i][j];
					}
				}
				if(p.score>p.optimal_score){
					p.optimal_score=p.score;
					for (int i = 0; i < map.length; i++) {
						for (int j = 0; j < map[i].length; j++) {
							optimal_map[i][j]=map[i][j];
						}
					}
				}
				timer.stop();
				JOptionPane.showMessageDialog(null, "游戏得分为："+p.score);
				int option=JOptionPane.showConfirmDialog(null, "是否再来一局？", "", JOptionPane.YES_NO_OPTION);
				if(option==JOptionPane.OK_OPTION){
					newGame();
				}else{
					//System.exit(0);
					dispose();
				}
			}
			
		}

		//消方块
		private void Deline() {
			int count=0;
			for (int i = 0; i < map.length-1; i++) {
				int c=1;
				for (int j = 1; j < map[i].length-1; j++) {
					c=c&map[i][j];
				}
				if(c==1){
					for (int i2 = i; i2 >0; i2--) {
						for (int j = 1; j < map[i2].length-1; j++) {
							map[i2][j]=map[i2-1][j];
						}
					}
					for (int j = 1; j < map[i].length-1; j++) {
						map[0][j]=0;
					}
					count++;
				}
			}
			if(count!=0){
				p.score+=10*(int)Math.pow(2, count);
				p.repaint();
			}
			timer.setDelay(delay-p.score/100);
		}

		//判断是否碰撞
		private int crash(int blockType, int turnState, int local_x, int local_y) {
			for (int i = 0; i < shapes[blockType][turnState].length; i++) {
				for (int j = 0; j < shapes[blockType][turnState][i].length; j++) {
					try {
						if((shapes[blockType][turnState][i][j]&map[local_y+i][local_x+j])==1)
							return 0;
					} catch (Exception e) {
						return 0;
					}
				}
			}
			return 1;
		}
 
		@Override
		protected void printComponent(Graphics g) {
			super.printComponent(g);
			//画出游戏界面
			for (int i = 0; i <map.length; i++) {
				for (int j = 0; j < map[i].length; j++) {
					if(map[i][j]==3){
						g.setColor(Color.gray);
						g.fillRect(j*20, i*20, 20, 20);
					}
					if(map[i][j]==1){
						g.setColor(Color.blue);
						g.fillRect(j*20, i*20, 20, 20);
					}
				}
			}
			if(timer!=null&&timer.isRunning())
			for (int i = 0; i < shapes[blockType][turnState].length; i++) {
				for (int j = 0; j < shapes[blockType][turnState][i].length; j++) {
					if(shapes[blockType][turnState][i][j]==1){
						g.setColor(Color.cyan);
						g.drawRect((local_x+j)*20, (local_y+i)*20, 20, 20);
						g.setColor(Color.blue);
						g.fillRect((local_x+j)*20+1, (local_y+i)*20+1, 19, 19);
					}
				}
			}
			
		}

		@Override
		public void paint(Graphics g) {
			printComponent(g);
		}
        /*
         * 键盘控制
         */
        class TimerListeren extends KeyAdapter implements ActionListener{

			@Override
			public void actionPerformed(ActionEvent e) {
				down();
			}

			@Override
			public void keyPressed(KeyEvent e) {
				if(timer==null||!timer.isRunning())
					return;
				int keyCode=e.getKeyCode();
				switch(keyCode){
				case KeyEvent.VK_DOWN:
					down();
					break;
				case KeyEvent.VK_UP:
					trun();
					break;
				case KeyEvent.VK_LEFT:
					left();
					break;
				case KeyEvent.VK_RIGHT:
					right();
					break;
				}
			}

        }

	}
	
	public class nextBlockJPanel extends JPanel {
		
		private int blockType;
		private int turnState; 
		
		private int score;
		private int now_score;
		private int last_score;
		private int optimal_score;
		
		public nextBlockJPanel(){
			nextBlock();
			score=0;
		}

		@Override
		protected void paintComponent(Graphics g) {
			super.paintComponent(g);
			g.drawString("下一个方块形状：", 20, 20);

			for (int i = 0; i <shapes[blockType][turnState].length ; i++) {
				for (int j = 0; j < shapes[blockType][turnState][i].length; j++) {
					if(shapes[blockType][turnState][i][j]==1){
						g.setColor(Color.cyan);
						g.drawRect(40+j*20, 40+i*20, 20, 20);
						g.setColor(Color.blue);
						g.fillRect(40+j*20+1, 40+i*20+1, 19, 19);
					}
				}
			}
			g.setColor(Color.red);
			g.drawString("Score:", 140, 20);
			g.setFont(new Font("score",Font.BOLD,50));
			g.drawString(""+score, 140, 80);
			g.setFont(new Font("aa", Font.PLAIN, 32));
			g.drawString("拒绝盗版游戏，", 20, 320);
			g.drawString("注意自我保护。", 20, 350);
			g.drawString("谨防受骗上当。", 20, 380);
			g.drawString("适度游戏益脑，", 20, 410);
			g.drawString("沉迷游戏伤身。", 20, 440);
			g.drawString("合理安排时间，", 20, 470);
			g.drawString("享受健康生活。", 20, 500);
		}

		@Override
		public void paint(Graphics g) {
			super.paint(g);
			paintComponent(g);
		}
		//下一个方块
		private void nextBlock() {
			blockType=(new Random()).nextInt(shapes.length);
			turnState=(new Random()).nextInt(shapes[blockType].length);
			repaint();
			
		}
		

	}
	
	public static void main(String[] args) {
		new Tetris();
	}
	
	

}

听听丶
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java小游戏 俄罗斯方块
06-23
java小游戏 俄罗斯方块java小游戏 俄罗斯方块java小游戏 俄罗斯方块java小游戏 俄罗斯方块java小游戏 俄罗斯方块java小游戏 俄罗斯方块java小游戏 俄罗斯方块java小游戏 俄罗斯方块java小游戏 俄罗斯方块java小游戏 ...
JAVA面向对象小程序（二）：俄罗斯方块s
J.R.Leonardo的博客
05-27 3559
今天，我们来使用Eclipse制作一个小游戏《Tetris~》 资源在文末 一、游戏机制 a) 7种小块儿随机生成 i.一块放置在顶部(随时间下降) ii.另一块置于右侧，提示下一个随机生成块 iii.七种形状：“O、L、J、I、T、S、...
适合Java初学者练手的几个Java小程序（完整可运行）
小虎哥的技术博客
07-21 5282
适合Java初学者练手的几个Java小程序，数字炸弹小游戏、掷骰子游戏、简单记账程序
Java实现俄罗斯方块小游戏。（附完整源代码）
热门推荐
我这么骄傲的一个人。
05-13 3万+
大家好，我是百思不得小赵。 创作时间：2022 年 5 月 12 日 博客主页： 🔍点此进入博客主页 —— 新时代的农民工 🙊 —— 换一种思维逻辑去看待这个世界 👀 今天是加入CSDN的第1167天。觉得有帮助麻烦👏点赞、🍀评论、❤️收藏 目录 一、游戏背景 二、功能实现 三、效果展示 四、总结 一、游戏背景 二、功能实现 三、效果展示 四、总结 Github链接地址：点击获取完整源代码，下载到本地即可运行 ...
教你用Java编写一个简单的小游戏
weixin_54542328的博客
10-31 1622
​ 这篇文章将向您展示如何使用Java编写一个简单的小游戏。我们将逐步介绍游戏的基本结构和实现的主要组件，以帮助您了解游戏开发的基本概念。
Java做一个简单的猜拳小游戏
一名想当程序员的人
05-21 3878
java制作一个猜拳小游戏
Java实现俄罗斯方块小游戏.zip
07-19
java课程设计大作业，java、算法练手项目，适合初学java、数据结构的同学拿来学习研究，基于java、GUI开发的小游戏，程序都经过测试，可以直接运行，资源含程序运行所需的源码、资源文件等全部数据，有需要的可放心...
Java俄罗斯方块小游戏
09-01
主要为大家详细介绍了Java俄罗斯方块小游戏，实现了俄罗斯的经典功能，感兴趣的小伙伴们可以参考一下
Java实现的俄罗斯方块小游戏.zip
最新发布
04-02
Java实现的俄罗斯方块小游戏.zipJava实现的俄罗斯方块小游戏.zip Java实现的俄罗斯方块小游戏.zipJava实现的俄罗斯方块小游戏.zip Java实现的俄罗斯方块小游戏.zipJava实现的俄罗斯方块小游戏.zip Java实现的俄罗斯...
Java版俄罗斯方块小游戏源码
08-31
俄罗斯方块是一款益智方块类游戏， 这款游戏最初是由苏联的电脑科学家帕吉特诺夫(Alex Pajitnov)于1985年制作的， 作者给了他一个源自希腊字4(tetra)的名字Tetris。 1989年由任天堂于发行GameBoy版，推出后风靡...
基于Java的俄罗斯方块游戏
m0_72438098的博客
07-01 88
基于Java的俄罗斯方块游戏，基于Java Swing技术，游戏分不同等级的难度。适合大作业、课程设计、毕业设计。基于Java的俄罗斯方块游戏，基于Java Swing技术，游戏分不同等级的难度。适合大作业、课程设计、毕业设计。基于Java的俄罗斯方块游戏，基于Java Swing技术，游戏分不同等级的难度。适合大作业、课程设计、毕业设计。Java、Swing。
纯Java语言实现的图形化项目——Lemon（好看的社交聊天个性化小程序）
m0_48489737的博客
11-12 573
本篇文章呢，向大家介绍一下早年写的第一个Java项目，纯Java写的一个图形化项目，用的还是内置的JFrame。。。呀，真是怀念呀，没什么，只是想记录一下，当时刚学习Java的心情。咳咳，不说废话，因为是刚学完Java基础的时候写的，没什么技术含量，就单纯的回忆一下，见笑。项目已经放到github上了，有兴趣的可以自取，附带程序设计报告书哦。还有我的注解写的超详细，那时候就有这个意识啦。
Java简易小游戏贪吃蛇（Java实战）
weixin_71766825的博客
07-20 5096
Java初学者实战篇，贪吃蛇小游戏（简易版）
用Java写一个简易五子棋游戏
m0_73249076的博客
10-16 1万+
用java写一个五子棋游戏，包含判断输赢、悔棋、复盘功能。
Java入门简单小游戏有哪些？
技术专家
11-25 6653
适合新手练习的小游戏有超级玛丽、愤怒的小鸟、飞机大战、五子棋、彩虹雨、聊天室、华容道、坦克大战、扫雷等。还有贪吃蛇，由Java开发出来的一款经典小游戏，java小白入门可以用这款游戏开发练手锻炼自己的编程能力。
用Java写一个小游戏
技术积累，技术分享
08-30 1万+
游戏开始图片 如下： 游戏胜利图片 如下： 游戏分析：        玩家控制键盘上下左右键，当数字按照从小到大依次排列的时候则玩家获胜 游戏功能： 1、在游戏的菜单栏中设置了游戏的重新开始案件 2、制作了一个作弊键 3、设置了游戏步数计数器 编写过程用到的小知识点 1、JFrame：是用来创建一个屏幕上的窗口 2、JMenuBar：是窗口上面的菜单栏 3、JMenu： 4、JMenuItem 5、JLabel 6、ImageIcon
java游戏代码大全_求一个简单的Java小游戏的代码
weixin_39522486的博客
02-12 1万+
展开全部连连看的小源码package Lianliankan;import javax.swing.*;import java.awt.*;import java.awt.event.*;public class lianliankan implements ActionListener{JFrame mainFrame; //主面32313133353236313431303231363533e...
一个简单的游戏源代码
爪哇米工作室陈跃峰的移动开发博客
09-08 1万+
  一个简单的游戏源代码作者：陈跃峰出自：http://blog.csdn.net/mailbomb        实现一个简单的翻牌游戏，每次最多翻开两个数字，如果数字相同则消失，否则两个数字不显示，可以继续游戏。       游戏规则如下：       1、游戏数据使用两个一维数组存储：u       map存储逻辑数据u       displayMap存储绘
java bufferedimage_Java 开发打飞机小游戏（附完整源码）
weixin_39912566的博客
11-29 527
上图写在前面技术源于分享，所以今天抽空把自己之前用java做过的小游戏整理贴出来给大家参考学习。java确实不适合写桌面应用，这里只是通过这个游戏让大家理解oop面向对象编程的过程，纯属娱乐。代码写的很简单，也很容易理解，并且注释写的很清楚了，还有问题，自己私下去补课学习。完整代码敌飞机importjava.util.Random;敌飞机:是飞行物，也是敌人publicclass...
用java写一个俄罗斯方块小游戏
10-26
要用Java写一个俄罗斯方块小游戏，可以按照以下步骤进行： 1. 创建一个Java项目，并添加必要的库文件。 2. 创建一个游戏窗口，可以使用Java Swing或JavaFX等GUI库。 3. 实现俄罗斯方块的基本逻辑，包括方块的生成、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值