奔跑吧小恐龙（Java）

前言 

        Google浏览器内含了一个小彩蛋当没有网络连接时，浏览器会弹出一个小恐龙，当我们点击它时游戏就会开始进行，大家也可以玩一下试试，网址：恐龙快跑 - 霸王龙游戏. (ur1.fun)

        今天我们也可以用Java来简单的实现一下这个小游戏。

一  系统功能结构图

二  系统业务流程图

 

三  程序目录结构

一  游戏模型设计

        游戏模型主要指游戏中出现的刚体。刚体是指不会因为受力而变形的物体。游戏中的刚体包括奔跑的恐龙，石头和仙人掌。背景图片虽然会滚动，但背景图片不参与任何碰撞检测，所以不属于游戏模型。

1.恐龙类 

        奔跑的小恐龙是游戏的主角，也是玩家控制的角色。项目中的model.Dinosaur就是恐龙类。

1-1 定义

        Dinosaur类的成员属性绝大多数都是私有属性，只有少数公有属性用于游戏面板绘图使用，如主图片和横纵坐标。Dinosaur类的私有属性包含3张来回切换的跑步图片，最大起跳高度，落地时的坐标以及各种状态的布尔值和计时器。

Dinosaur类的定义：

public class Dinosaur {public BufferedImage image;                    //主图片private BufferedImage image1,image2,image3;    //跑步图片public int x,y;                                //坐标private int jumpValue = 0;                     //跳跃的增变量private boolean jumpState = false;             //跳跃的状态private int stepTimer = 0;                     //踏步计时器private final int JUMP_HIGHT = 100;            //最大跳起高度private final int LOWEST_Y = 120;              //落地最低坐标private final int FREASH = FreshThread.FREASH; //刷新时间
}

 在构造方法中我们要设置恐龙的初始状态，将恐龙横坐标固定在50像素，纵坐标采用落地时的坐标120像素，构造方法的代码如下：

	public Dinosaur() {x=50;//横坐标默认是50；y=LOWEST_Y;//纵坐标默认起始值是120image1=ImageIO.read(new File("image/恐龙1.png"));image2=ImageIO.read(new File("image/恐龙2.png"));image3=ImageIO.read(new File("image/恐龙3.png"));}

1-2.踏步

        游戏中恐龙的横坐标不变但是，背景的运动会使恐龙呈现一中运动的状态，为了使这种假象的运动状态逼真，我们就需要做出恐龙奔跑的动作。step()的方法就是踏步，我们只需要将图片来回切换就可以做到这种效果。

	public void step() {// 每过250毫秒，更换一张图片。因为共有3图片，所以除以3取余，轮流展示这三张int tmp = stepTimer/250%3;switch(tmp) {case 1:image = image1;break;case 2:image = image2;break;default:image = image3;}stepTimer += FREASH;//计时器递增}

1-3.跳跃

        跳跃是小恐龙躲避障碍的动作，也是我们唯一可以控制恐龙的 行为。当程序调用jump()方法时，该方法会更改恐龙的跳跃属性，也就是让恐龙处于跳跃状态，跳跃的同时也会触发音效。

	/*** 跳跃*/public void jump() {if (!jumpState) {// 如果没处于跳跃状态Sound.jump();// 播放跳跃音效}jumpState = true;// 处于跳跃状态}

 1-4.移动

        move方法是恐龙移动方法，该方法将恐龙的所有动作效果封装起来，然后交由游戏面板调用。每一帧画面都会执行一次恐龙的move方法。move 方法不断地调用step踏步方法，因为stepTimer踏步计时器会有效控制图片的切换频率，所以不用担心频繁调用的问题。
move()方法会判断恐龙是否处于跳跃状态，如果处于跳跃状态，并且恐龙站在地上，就让jumpValue跳跃增变量值变为-4，让恐龙的纵坐标不断与jumpValue 相加，纵坐标值越来越小，这样恐龙的图片位置就会越来越高。当恐龙纵坐标达到跳跃最大高度时，再让jumpValue的值变为4，纵坐标值越来越大，恐龙的图片就会越来越低。当恐龙再次回到地面上时，取消跳跃状态。至此，恐龙就完成了一次跳跃动作。

	/** 移动的方法*/public void move() {step();//不断踏步if(jumpState) {//如果正在跳跃if(y>=LOWEST_Y) {//如果纵坐标大于等于最低点jumpValue = -4;//增变量为负值/** 这是因为我们窗体的显示是按照像素的大小和位置决定的* ，从左上角开始横纵坐标均为0,然后开始增长,向下y增长,向右x增长*/	}if(y<=LOWEST_Y-JUMP_HIGHT) {//如果跳过最高点jumpValue = 4;//增变量为正值}y+=jumpValue;//纵坐标发生变化if(y>=LOWEST_Y) {//如果再次落地jumpState = false;// 停止跳跃}}}

1-5.边界对象

        因为我们这里设计的有跳跃的状态，那么就要设置判断是否发生碰撞，我们这里将物体具体化为矩形类型方便处理，和判断是否发生碰撞，将恐龙的头和脚抽象具体为矩形。

    /*** 足部边界区域* * @return*/public Rectangle getFootBounds() {return new Rectangle(x + 30, y + 59, 29, 18);}/*** 头部边界区域* * @return*/public Rectangle getHeadBounds() {return new Rectangle(x + 66, y + 25, 32, 22);

 2 .障碍类

游戏中设置了两种障碍：

        一种是很矮的石头：

        一种是很高的仙人掌：

  不管是石头还是仙人掌，每一个障碍的特点都大致相同：都会随着背景一起移动，都是可能碰撞的区域。

2-1.定义

         Obstacle类就是障碍类，该类提供了3个共有属性，分别是横坐标，纵坐标和图片对象，其他属性均为私有属性。因为障碍都会随着背景一起移动，所以障碍的移动速度采用背景图片的速度。

public class Obstacle {public int x, y;// 横纵坐标public BufferedImage image;private BufferedImage stone;// 石头图片private BufferedImage cacti;// 仙人掌图片private int speed;// 移动速度
}

         使用构造方法随机生成仙人掌或石头，采用随机数的方法生成0和1，0表示采用仙人掌的图片，1表示采用石头的图片。

    public Obstacle() {try {stone = ImageIO.read(new File("image/石头.png"));cacti = ImageIO.read(new File("image/仙人掌.png"));} catch (IOException e) {e.printStackTrace();}Random r = new Random();// 创建随机对象if (r.nextInt(2) == 0) {// 从0和1中取一值，若为0image = cacti;// 采用仙人掌图片} else {image = stone;// 采用石头图片}x = 800;// 初始横坐标y = 200 - image.getHeight();// 纵坐标speed = BackgroundImage.SPEED;// 移动速度与背景同步}

2-2.移动

        由于我们的画面中恐龙是在原地不同的，而背景画面是向左走的，因此我们的障碍物也要向左移动，像素的位置向左移动也就是行坐标的像素减少。同样我们也设置障碍物的移动方法为move()；

    /*** 移动*/public void move() {x -= speed;// 横坐标递减}

2-3.消除

        当障碍移除游戏画面以后，就不会在的游戏的数据产生影响。为了减除程序计算的压力，我们要将移除游戏画面的障碍消除。isLive()方法用于获取障碍的有效状态，该方法会根据障碍的位置判断返回true和flase，当障碍还在窗体内返回true表示还在窗体内，flase表示没在窗体内，将障碍对象从碰撞集合中删除。

    /*** 是否存活* * @return*/public boolean isLive() {// 如果移出了游戏界面if (x <= -image.getWidth()) {return false;// 消亡}return true;// 存活}

2-4.边界对象

        为将障碍具体化设置为矩形，方便后面参与碰撞检测，不管是仙人掌还是石头，都要通过getBounds()方法返回边界对象

    public Rectangle getBounds() {if (image == cacti) {// 如果使用仙人掌图片// 返回仙人掌的边界return new Rectangle(x + 7, y, 15, image.getHeight());}// 返回石头的边界return new Rectangle(x + 5, y + 4, 23, 21);}

二  音效模块设计

        当然一款游戏离不开音乐的支持。因为音频处理功能是JDK早期版本就有，并且一直没有更新，所以目前JDK支持的音乐格式很少。JDK支持的音乐格式可以参看：在线文档-jdk-zh (oschina.net)

        我们这里使用JDK支持的WAVE格式

1.音频播放器

        MusicPlayer类是音频播放器类，该类实现了Runnable接口，并在线程中定义了一个线程对象，该线程用于启动混音器数据行的业务。

public class MusicPlayer implements Runnable{File soundFile;               //音乐文件Thread thread;                //父线程boolean circulate;            //是否循环播放
}

        它的构造方法有两个参数。filepath表示音乐文件的完整文件名，circulate表示是否重复播放，构造方法抛出找不到文件异常，外部类创建MusicPlayer类对象时，必须要捕捉此异常。

    /*** 构造方法，默认不循环播放* * @param filepath*            音乐文件完整名称* @throws FileNotFoundException*/public MusicPlayer(String filepath) throws FileNotFoundException {this(filepath, false);}/*** 构造方法* * @param filepath*            音乐文件完整名称* @param circulate*            是否循环播放* @throws FileNotFoundException*/public MusicPlayer(String filepath, boolean circulate) throws FileNotFoundException {this.circulate = circulate;soundFile = new File(filepath);if (!soundFile.exists()) {// 如果文件不存在throw new FileNotFoundException(filepath + "未找到");}}

        既然此类实现了Runnable接口，必须实现run()方法。在run()方法中声明了一个128kb的缓冲字节数组，程序以不断循环的方式将音乐以音频输入流格式读入缓冲区，在把缓冲区的数据写入混音器数据行中，这样就可以不断向外部音频设备发送音频信号，实现播放音乐的效果。

    /**重写线程执行方法*/@Overridepublic void run() {byte[] auBuffer = new byte[1024 * 128];// 创建128k缓冲区do {AudioInputStream audioInputStream = null; // 创建音频输入流对象SourceDataLine auline = null; // 混频器源数据行try {// 从音乐文件中获取音频输入流audioInputStream = AudioSystem.getAudioInputStream(soundFile);AudioFormat format = audioInputStream.getFormat(); // 获取音频格式// 按照源数据行类型和指定音频格式创建数据行对象DataLine.Info info = new DataLine.Info(SourceDataLine.class,format);// 利用音频系统类获得与指定 Line.Info 对象中的描述匹配的行，并转换为源数据行对象auline = (SourceDataLine) AudioSystem.getLine(info);auline.open(format);// 按照指定格式打开源数据行auline.start();// 源数据行开启读写活动int byteCount = 0;// 记录音频输入流读出的字节数while (byteCount != -1) {// 如果音频输入流中读取的字节数不为-1// 从音频数据流中读出128K的数据byteCount = audioInputStream.read(auBuffer, 0,auBuffer.length);if (byteCount >= 0) {// 如果读出有效数据auline.write(auBuffer, 0, byteCount);// 将有效数据写入数据行中}}} catch (IOException e) {e.printStackTrace();} catch (UnsupportedAudioFileException e) {e.printStackTrace();} catch (LineUnavailableException e) {e.printStackTrace();} finally {auline.drain();// 清空数据行auline.close();// 关闭数据行}} while (circulate);// 根据循环标志判断是否循环播放}

        播放音乐和停止音乐的方法如下：使用start方法启动线程来播放音乐，使用stop方法来强制关闭线程，实现关闭音乐的效果。

    /*** 播放*/public void play() {thread = new Thread(this);// 创建线程对象thread.start();// 开启线程}/*** 停止播放*/public void stop() {thread.stop();// 强制关闭线程}/*

2.音效工具类

        我们知道游戏设计有跳的动作以及碰撞的效果，这些都要添加一些音效才能够使游戏的效果更加好。所以我们可以为每一个动作设计一个单独的线程，当要执行该动作时启动一次线程之后再关闭即可。

package service;import java.io.FileNotFoundException;
/*** 音效类* @author JWF*/
public class Sound {static final String DIR = "music/";// 音乐文件夹static final String BACKGROUD = "background.wav";// 背景音乐static final String JUMP = "jump.wav";// 跳跃音效static final String HIT = "hit.wav";// 撞击音效/*** 播放跳跃音效*/static public void jump() {play(DIR + JUMP, false);// 播放一次跳跃音效}/*** 播放撞击音效*/static public void hit() {play(DIR + HIT, false);// 播放一次撞击音效}/*** 播放背景音乐*/static public void backgroud() {play(DIR + BACKGROUD, true);// 循环播放背景音乐}/*** 播放* * @param file*            音乐文件完整名称* @param circulate*            是否循环播放*/private static void play(String file, boolean circulate) {try {// 创建播放器MusicPlayer player = new MusicPlayer(file, circulate);player.play();// 播放器开始播放} catch (FileNotFoundException e) {e.printStackTrace();}}
}

三  计分器模块设计

        这里计分器使用一个静态的整型数组记录有史以来前三名的成绩，当玩家打破记录时计分器会更新分数，此类为ScoreRecorder类定义如下：

public class ScoreRecorder {private static final String SCOREFILE = "data/soure";// 得分记录文件private static int scores[] = new int[3];// 当前得分最高前三名
}

读取原始分数数据初始化 

        在使用ScoreRecorder类之前，需要先调用该类的静态方法init。init方法可以让计分器从成绩记录文件中读取到历史前3名数据。成绩记录文件记录了3个历史成绩，这3个成绩升序排列并用“，”分隔。如果成绩记录文件不存在，或者文件中没有记录有效成绩，则会取消读取操作，并让历史前3名成绩均为0。init0方法的具体代码如下：

    /*** 分数初始化*/public static void init() {File f = new File(SCOREFILE);// 创建记录文件if (!f.exists()) {// 如果文件不存在try {f.createNewFile();// 创建新文件} catch (IOException e) {e.printStackTrace();}return;// 停止方法}FileInputStream fis = null;InputStreamReader isr = null;BufferedReader br = null;try {fis = new FileInputStream(f);// 文件字节输入流isr = new InputStreamReader(fis);// 字节流转字符流br = new BufferedReader(isr);// 缓冲字符流String value = br.readLine();// 读取一行if (!(value == null || "".equals(value))) {// 如果不为空值String vs[] = value.split(",");// 分割字符串if (vs.length < 3) {// 如果分割结果小于3Arrays.fill(scores, 0);// 数组填充0} else {for (int i = 0; i < 3; i++) {// 将记录文件中的值赋给当前分数数组scores[i] = Integer.parseInt(vs[i]);}}}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {// 依次关闭流try {br.close();} catch (IOException e) {e.printStackTrace();}try {isr.close();} catch (IOException e) {e.printStackTrace();}try {fis.close();} catch (IOException e) {e.printStackTrace();}}}

写入游戏数据并保存 

        当游戏停止时，要记录最新的前三名的成绩。saveSore()方法可以将当前成绩数组中的值写入成绩记录文件中。

/*** 保存分数*/public static void saveScore() {// 拼接得分数组String value = scores[0] + "," + scores[1] + "," + scores[2];FileOutputStream fos = null;OutputStreamWriter osw = null;BufferedWriter bw = null;try {fos = new FileOutputStream(SCOREFILE);// 文件字节输出流osw = new OutputStreamWriter(fos);// 字节流转字符流bw = new BufferedWriter(osw);// 缓冲字符流bw.write(value);// 写入拼接后的字符串bw.flush();// 字符流刷新} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();} finally {// 依次关闭流try {bw.close();} catch (IOException e) {e.printStackTrace();}try {osw.close();} catch (IOException e) {e.printStackTrace();}try {fos.close();} catch (IOException e) {e.printStackTrace();}}}

        addNewScore()方法用于向成绩数组中添加新成绩，该方法的score参数就是要添加的新成绩数值。在addNewScoreO方法中，如果添加的新成绩小于历史前3名，则会舍弃；如果新成绩大于历史前3名中的某个成绩，则会重新排列前3名成绩。这个逻辑是通过Arrays 类提供的 sort排序方法和copyOfRange()复制数组元素方法实现的.

/*** 添加分数。如果新添加的分数比排行榜分数高，则会将新分数记入排行榜。* * @param score*         新分数*/static public void addNewScore(int score) {// 在得分组数基础上创建一个长度为4的临时数组int tmp[] = Arrays.copyOf(scores, 4);tmp[3] = score;// 将新分数赋值给第四个元素Arrays.sort(tmp);// 临时数组降序排列scores = Arrays.copyOfRange(tmp, 1, 4);// 将后三个元素赋值给得分数组}

获取分数的方法

    /*** 获取分数* * @return*/static public int[] getScores() {return scores;}

四  视图模块设计

一   主窗体

        主窗体是整个游戏最外层的容器。主窗体的本身没有任何内容，仅是一个宽820像素,高260像素的窗体。项目中 view.MainFrame类表示游戏的主窗体类，该类继承于JFrame类。MainFrame类没有成员属性。MainFrame 类的构造方法中定义了窗体的宽、高、标题等特性，同时也具有游戏启动时的初始化功能。例如，第一次载入游戏面板时，初始化计分器，播放背景音乐等。MainFrame类的构造方法的具体代码如下：

    public MainFrame() {restart();// 开始setBounds(340, 150, 821, 260);// 设置横纵坐标和宽高setTitle("奔跑吧！小恐龙！");// 标题Sound.backgroud();// 播放背景音乐ScoreRecorder.init();// 读取得分记录addListener();// 添加监听setDefaultCloseOperation(EXIT_ON_CLOSE);// 关闭窗体则停止程序}

        构造方法中调用的 restart方法就是让游戏重新开始的方法，也可以用于第一次启动游戏在restart)方法中，首先获取了窗体的主容器对象，然后删除容器中的所有组件，最后创建一个新的游戏面板对象并添加到容器中，同时添加主窗体的键盘事件。方法中最后一行代码尤为关键，如果在删除原组件并添加新的游戏面板之后不做重新验证操作，将会导致新面板无法正确显示。restart()方法的具体代码如下：

    /*** 重新开始*/public void restart() {Container c = getContentPane();// 获取主容器对象c.removeAll();// 删除容器中所有组件GamePanel panel = new GamePanel();// 创建新的游戏面板c.add(panel);addKeyListener(panel);// 添加键盘事件c.validate();// 容器重新验证所有组件}

        构造方法中调用了addListener()方法用于让窗体添加键盘以外的监听事件，游戏中主要用于在关闭窗口之前保存最新的得分记录。在窗体关闭之前会触发windowClosing()方法，在此方法中调用ScoreRecord计分器的saveScore()方法保存成绩。

    /*** 添加监听*/private void addListener() {addWindowListener(new WindowAdapter() {// 添加窗体监听public void windowClosing(WindowEvent e) {// 窗体关闭前ScoreRecorder.saveScore();// 保存得分记录}});}

二   游戏面板

        游戏面板是整个程序的核心，几乎所有的算法都是以游戏面板为基础实现的。游戏面板的主要作用是绘制游戏界面，将所有的游戏元素都展现出来。游戏界面会按照(默认)20毫秒一次的刷新频率实现游戏帧数的刷新，这样不仅可以让界面中的元素运动起来，也可以让各个元素在运动的过程中进行逻辑的运算。


        项目中的 GamePanel 类表示游戏面板类，该类继承了JPanel面板类，同时实现了KeyListener 键盘事件监听接口。GamePanel类有很多成员属性，其中恐龙对象、背景图片对象、障碍集合和得分都是游戏界面中可以看到的元素。此外，还有很多后台使用的属性，如游戏结束标志、障碍计时器等。
        游戏采用双缓冲机制防止界面闪烁，image对象就是缓冲图片对象，也可以成为主图片对象，所有的游戏画面都绘制在image对象中，然后再将image对象绘制到游戏面板中。GamePanel类的定义如下：

public class GamePanel extends JPanel implements KeyListener {private BufferedImage image;// 主图片private BackgroundImage background;// 背景图片private Dinosaur golden;// 恐龙private Graphics2D g2;// 主图片绘图对象private int addObstacleTimer = 0;// 添加障碍计时器private boolean finish = false;// 游戏结束标志private List<Obstacle> list = new ArrayList<Obstacle>();// 障碍集合private final int FREASH = FreshThread.FREASH;// 刷新时间int score = 0;// 得分int scoreTimer = 0;// 分数计时器public GamePanel() {// 主图片采用宽800高300的彩色图片image = new BufferedImage(800, 300, BufferedImage.TYPE_INT_BGR);g2 = image.createGraphics();// 获取主图片绘图对象background = new BackgroundImage();// 初始化滚动背景golden = new Dinosaur();// 初始化小恐龙list.add(new Obstacle());// 添加第一个障碍FreshThread t = new FreshThread(this);// 刷新帧线程t.start();// 启动线程}
}

        在paintlmage)方法中会让每一个游戏元素都执行各自的运动，如背景图片的滚动、恐龙的移动和障碍的移动等。在绘制障碍之前，会先判断障碍集合中的障碍对象是否是有效的，如是无效障碍，则会删除。paintImage0方法的具体代码如下：

    /*** 绘制主图片*/private void paintImage() {background.roll();// 背景图片开始滚动golden.move();// 恐龙开始移动g2.drawImage(background.image, 0, 0, this);// 绘制滚动背景if (addObstacleTimer == 1300) {// 每过1300毫秒if (Math.random() * 100 > 40) {// 60%概率出现障碍list.add(new Obstacle());}addObstacleTimer = 0;// 重新计时}for (int i = 0; i < list.size(); i++) {// 遍历障碍集合Obstacle o = list.get(i);// 获取障碍对象if (o.isLive()) {// 如果是有效障碍o.move();// 障碍移动g2.drawImage(o.image, o.x, o.y, this);// 绘制障碍// 如果恐龙头脚碰到障碍if (o.getBounds().intersects(golden.getFootBounds())|| o.getBounds().intersects(golden.getHeadBounds())) {Sound.hit();// 播放撞击声音gameOver();// 游戏结束}} else {// 如果不是有效障碍list.remove(i);// 删除此障碍i--;// 循环变量前移}}g2.drawImage(golden.image, golden.x, golden.y, this);// 绘制恐龙if (scoreTimer >= 500) {// 每过500毫秒score += 10;// 加十分scoreTimer = 0;// 重新计时}g2.setColor(Color.BLACK);// 使用黑色g2.setFont(new Font("黑体", Font.BOLD, 24));// 设置字体g2.drawString(String.format("%06d", score), 700, 30);// 绘制分数addObstacleTimer += FREASH;// 障碍计时器递增scoreTimer += FREASH;// 分数计时器递增}

        重绘组件的方法，以及判断游戏是否结束等方法都要实现，还有因为我们类实现的结构，就要实现具体的方法。

    /*** 重写绘制组件方法*/public void paint(Graphics g) {paintImage();// 绘制主图片内容g.drawImage(image, 0, 0, this);}/*** 游戏是否结束* * @return*/public boolean isFinish() {return finish;}/*** 使游戏结束*/public void gameOver() {ScoreRecorder.addNewScore(score);// 记录当前分数finish = true;}/*** 实现按下键盘按键方法*/public void keyPressed(KeyEvent e) {int code = e.getKeyCode();// 获取按下的按键值if (code == KeyEvent.VK_SPACE) {// 如果是空格golden.jump();// 恐龙跳跃}}@Overridepublic void keyReleased(KeyEvent e) {}@Overridepublic void keyTyped(KeyEvent e) {}

三   成绩对话框

        成绩对话框会在游戏结束时弹出，对话框中会显示目前为止记录的前3名成绩，单击对话框底部的按钮会重新开始游戏。项目中的 view.ScoreDialog就是成绩对话框类，该类继承JDialog对话框类。
        ScoreDialog类中有一个构造方法，构造方法参数为对话框的父窗体。构造方法第一行调用了父类的构造方法，通过父类构造方法阻塞父窗体，这样可以保证弹出成绩对话框之后，主窗体内会停止全部功能且不可选中。这样可以保证玩家单击“重新开始”按钮后，主窗体才会执行restart()方法。

public class ScoreDialog extends JDialog {/*** 构造方法* * @param frame*            父窗体*/public ScoreDialog(JFrame frame) {super(frame, true);// 调用父类构造方法,阻塞父窗体int scores[] = ScoreRecorder.getScores();// 获取当前前三名成绩JPanel scoreP = new JPanel(new GridLayout(4, 1));// 成绩面板，4行1列scoreP.setBackground(Color.WHITE);// 白色背景JLabel title = new JLabel("得分排行榜", JLabel.CENTER);// 标题标签，居中title.setFont(new Font("黑体", Font.BOLD, 20));// 设置字体title.setForeground(Color.RED);// 红色体字JLabel first = new JLabel("第一名：" + scores[2], JLabel.CENTER);// 第一名标签JLabel second = new JLabel("第二名：" + scores[1], JLabel.CENTER);// 第二名标签JLabel third = new JLabel("第三名：" + scores[0], JLabel.CENTER);// 第三名标签JButton restart = new JButton("重新开始");// 重新开始按钮restart.addActionListener(new ActionListener() {// 按钮添加事件监听@Overridepublic void actionPerformed(ActionEvent e) {// 当点击时dispose();// 销毁对话框}});scoreP.add(title);// 成绩面板添加标签scoreP.add(first);scoreP.add(second);scoreP.add(third);Container c = getContentPane();// 获取主容器c.setLayout(new BorderLayout());// 使用边界布局c.add(scoreP, BorderLayout.CENTER);// 成绩面板放中间c.add(restart, BorderLayout.SOUTH);// 按钮放底部setTitle("游戏结束");// 对话框标题int width, height;// 对话框宽高width = height = 200;// 对话框宽高均为200// 获得主窗体中居中位置的横坐标int x = frame.getX() + (frame.getWidth() - width) / 2;// 获得主窗体中居中位置的纵坐标int y = frame.getY() + (frame.getHeight() - height) / 2;setBounds(x, y, width, height);// 设置坐标和宽高setVisible(true);// 显示对话框}
}

五   游戏核心功能设计

 一  刷新帧

        帧是一个量词，一幅静态画面就是一帧。无数不同的静态画面交替放映，就形成了动画。帧的刷新频率决定着画面中的动作是否流畅，列如，电影在正常情况下是24帧，也就是影片一秒钟会闪过24幅静态画面。想让游戏中的物体运动起来，就需要让游戏画面不断地刷新，像播放电影一样，这就是刷新帧的概念。
        项目中的service.FreshThead类就是游戏中的刷新帧线程类，该类继承于Thread线程类，并在线程的主方法中无限地循环，每过20毫秒就执行游戏面板的repaint)方法，每次执行 repaint0方法前都会先执行用户输入的指令，这样每次绘制的画面就会都不一样，极短时间内切换画面就形成了动画效果。游戏面板的isFinish)方法返回 false，就代表游戏结束，当前线程才会停止。
        当刷新帧的业务停止后，程序会获取加载游戏面板的主窗体对象，然后弹出成绩对话框，最后让主窗体对象重新开始新游戏。FreshThead类的具体代码如下：

public class FreshThread extends Thread {public static final int FREASH = 20;// 刷新时间GamePanel p;// 游戏面板public FreshThread(GamePanel p) {this.p = p;}public void run() {while (!p.isFinish()) {// 如果游戏未结束p.repaint();// 重绘游戏面板try {Thread.sleep(FREASH);// 按照刷新时间休眠} catch (InterruptedException e) {e.printStackTrace();}}Container c = p.getParent();// 获取面板父容器while (!(c instanceof MainFrame)) {// 如果父容器不是主窗体类c = c.getParent();// 继续获取父容器的父容器}MainFrame frame = (MainFrame) c;// 将容器强制转换为主窗体类new ScoreDialog(frame);// 弹出得分记录对话框frame.restart();// 主窗体重载开始游戏}
}

二  滚动背景

        前面我们提到了小恐龙的实际运动是在原地踏步，要想实现移动效果实际上是背景图片在向后移动，我们设计的背景图片一共有两张，通过这两张的不断循环，无缝衔接来实现背景滚动的效果。

public class BackgroundImage {public BufferedImage image;// 背景图片private BufferedImage image1, image2;// 滚动的两个图片private Graphics2D g;// 背景图片的绘图对象public int x1, x2;// 两个滚动图片的坐标public static final int SPEED = 4;// 滚动速度
}

构造方法

    public BackgroundImage() {try {image1 = ImageIO.read(new File("image/背景.png"));image2 = ImageIO.read(new File("image/背景.png"));} catch (IOException e) {e.printStackTrace();}// 主图片采用宽800高300的彩色图片image = new BufferedImage(800, 300, BufferedImage.TYPE_INT_RGB);g = image.createGraphics();// 获取主图片绘图对象x1 = 0;// 第一幅图片初始坐标为0x2 = 800;// 第二幅图片初始横坐标为800g.drawImage(image1, x1, 0, null);}

        roll方法让图片实现不断的滚动，当有任意一张图片移动出画面时，就立刻回到右侧是初始位置，准备下一轮的滚动。

    /*** 滚动*/public void roll() {x1 -= SPEED;// 第一幅图片左移x2 -= SPEED;// 第二幅图片左移if (x1 <= -800) {// 如果第一幅图片移出屏幕x1 = 800;// 回到屏幕右侧}if (x2 <= -800) {// 如果第二幅图片移出屏幕x2 = 800;// 回到屏幕右侧}g.drawImage(image1, x1, 0, null); // 在主图片中绘制两幅图片g.drawImage(image2, x2, 0, null);}

 

三  碰撞检测

        java awt.Rectangle类提供了intersects(Rectangle r)方法来判断两个边界是否发生了交汇。当两个边界对象发生交汇时，intersects()方法的返回结果为true；当两个边界对象没有交汇时，intersects()方法的返回结果为false。

        因为我们前面为恐龙和石头以及仙人掌做了边界处理，因此我们可以用这个方法来检测是否发生碰撞。

        在GamePanel游戏面板类的paintImage（）方法中，绘制完每一个障碍后，会判断刚刚绘制的障碍对象是否碰到了恐龙。利用上述的方法进行判断，只要存在true结果，就让游戏结束。

  if (o.getBounds().intersects(golden.getFootBounds())|| o.getBounds().intersects(golden.getHeadBounds())) {Sound.hit();// 播放撞击声音gameOver();// 游戏结束}

四  键盘监听

        前面GamePanel类实现了KeyListener的接口,该接口实现了三种方法(键盘监听的方法)：keyPressed，keyReleased，keyTyped.这里我们就用到了按下的监听事件实现的方法，如果点击空格键就让恐龙实现跳跃的方法。

    public void keyPressed(KeyEvent e) {int code = e.getKeyCode();// 获取按下的按键值if (code == KeyEvent.VK_SPACE) {// 如果是空格golden.jump();// 恐龙跳跃}}

【 游戏运行效果】

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/683625.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

FileZilla Server 1.8.1内网搭建

FileZilla Server 1.8.1内网搭建

配置环境服务器服务器下载服务器配置服务器配置 Server - ConfigureServer Listeners - Port 协议设置 Protocols settingsFTP and FTP over TLS(FTPS) Rights management(权利管理)Users(用户) 客户端建立连接 配置环境 服务器处于局域网内: 客户端 < -访问- > 公网 &l…
阅读更多...
[嵌入式系统-17]：RT-Thread -3- 源代码目录结构

[嵌入式系统-17]：RT-Thread -3- 源代码目录结构

目录 前言&#xff1a;功能模块 一、RT-Thread 源代码目录结构 二、支持的CPU架构 三、SRC内核代码 前言&#xff1a;功能模块 一、RT-Thread 源代码目录结构 从RT-Thread的GitHub官网上面下载了内核源码&#xff0c;下载链接如下 https://github.com/RT-Thread/rt-thread…
阅读更多...
HarmonyOS 通过getInspectorByKey获取指定元素高宽等属性

HarmonyOS 通过getInspectorByKey获取指定元素高宽等属性

例如 这里 我们有这样一个组件 Entry Component struct Dom {build() {Column() {Row() {Circle({ width: 200, height: 200 }).fill(#20101010)}.id(ES)}.width(100%).height(100%)} }这里 我们就写了个很基本的组件结构 然后 我们写了个 Circle 组件 定义了宽高 然后 如果我…
阅读更多...
数据接收程序

数据接收程序

#include<reg51.h> //包含单片机寄存器的头文件 sbit pPSW^0; /***************************************************** 函数功能&#xff1a;接收一个字节数据 ***************************************************/ unsigned char Receive(void) { unsigned…
阅读更多...
116. 填充每个节点的下一个右侧节点指针

116. 填充每个节点的下一个右侧节点指针

给定一个 完美二叉树 &#xff0c;其所有叶子节点都在同一层&#xff0c;每个父节点都有两个子节点。二叉树定义如下&#xff1a; struct Node {int val;Node *left;Node *right;Node *next; } 填充它的每个 next 指针&#xff0c;让这个指针指向其下一个右侧节点。如果找不到…
阅读更多...
Flink理论—容错之状态

Flink理论—容错之状态

Flink理论—容错之状态 在 Flink 的框架中&#xff0c;进行有状态的计算是 Flink 最重要的特性之一。所谓的状态&#xff0c;其实指的是 Flink 程序的中间计算结果。Flink 支持了不同类型的状态&#xff0c;并且针对状态的持久化还提供了专门的机制和状态管理器。 Flink 使用…
阅读更多...
7 大 Android 数据恢复软件，可轻松找回丢失的数据

7 大 Android 数据恢复软件，可轻松找回丢失的数据

每年&#xff0c;由于各种原因&#xff0c;数百万人从他们的 Android 设备中丢失数据。它可能像意外删除文件一样简单&#xff0c;也可能像系统崩溃一样复杂。在这种情况下&#xff0c;拥有高效的数据恢复工具可以证明是救命稻草。Mac 用户尤其需要找到与其系统兼容的软件。好消…
阅读更多...
不止于浏览器：掌握Node.js，开启全栈开发新篇章！

不止于浏览器：掌握Node.js，开启全栈开发新篇章！

介绍&#xff1a;Node.js是一个基于Chrome V8引擎的JavaScript运行时环境&#xff0c;特别适合构建高性能的网络服务器和实时应用。具体介绍如下&#xff1a; 服务器端JavaScript&#xff1a;Node.js的核心优势之一是在服务器端运行JavaScript&#xff0c;这使得前端开发者可以…
阅读更多...
如何利用SpringSecurity进行认证与授权

如何利用SpringSecurity进行认证与授权

目录 一、SpringSecurity简介 1.1 入门Demo 二、认证 ​编辑 2.1 SpringSecurity完整流程 2.2 认证流程详解 2.3 自定义认证实现 2.3.1 数据库校验用户 2.3.2 密码加密存储 2.3.3 登录接口实现 2.3.4 认证过滤器 2.3.5 退出登录 三、授权 3.1 权限系统作用 3.2 授…
阅读更多...
软件实例分享，门诊处方软件存储模板处方笺教程，个体诊所电子处方开单系统软件教程

软件实例分享，门诊处方软件存储模板处方笺教程，个体诊所电子处方开单系统软件教程

软件实例分享&#xff0c;门诊处方软件存储模板处方笺教程&#xff0c;个体诊所电子处方开单系统软件教程、 一、前言 以下软件教程以 佳易王诊所电子处方管理软件V17.0为例说明 软件文件下载可以点击最下方官网卡片——软件下载——试用版软件下载 电子处方软件支持病历汇总…
阅读更多...
CGAL Mesh分割

CGAL Mesh分割

文章目录 一、简介二、实现代码三、实现效果参考资料一、简介 网格分割是将一个网格分解成更小的、有意义的子网格的过程。该过程用于建模，索具，纹理，形状检索，变形等应用。CGAL为我们提供了一个依赖于形状直径函数(SDF)的算法实现，即给定一个三角形表面网格包围一个3D实体…
阅读更多...
对进程与线程的理解

对进程与线程的理解

目录 1、进程/任务&#xff08;Process/Task&#xff09; 2、进程控制块抽象(PCB Process Control Block) 2.1、PCB重要属性 2.2、PCB中支持进程调度的一些属性 3、 内存分配 —— 内存管理&#xff08;Memory Manage&#xff09; 4、线程&#xff08;Thread&#xff09;…
阅读更多...
auto关键字详讲

auto关键字详讲

目录 1.问题思考 2.auto关键字介绍 3. 早期auto的缺陷&#xff1a; 4.什么叫自动存储器&#xff1f; 5. c标准auto关键字 5.1auto的使用细节 5.2 auto什么时候不能推导变量的类型呢&#xff1f; 5.3基于范围的for循环 5.3.1范围for的用法 5.3.2 范围for的使用条件 6.…
阅读更多...
书生浦语大模型实战营-课程笔记（3）

书生浦语大模型实战营-课程笔记（3）

本节课主要是跟着教程做的&#xff0c;操作的东西放到作业里记录了。 这里主要记录一些视频里讲的非操作性的东西。 RAG外挂知识库&#xff1f;优点是成本低&#xff0c;不用重新训练 RAG的一个整体流程。 涉及了文本相似度匹配&#xff0c;是不是和传统的问答系统&#xff0…
阅读更多...
【Linux学习】线程池

【Linux学习】线程池

目录 23.线程池 23.1 什么是线程池 23.2 为什么需要线程池 23.3 线程池的应用场景 23.4 实现一个简单的线程池 23.4.1 RAII风格信号锁 23.4.2 线程的封装 23.4.3 日志打印 22.4.4 定义队列中存放Task类任务 23.4.5 线程池的实现(懒汉模式) 为什么线程池中需要有互斥锁和条件变…
阅读更多...
片上网络NoC（3）——拓扑指标

片上网络NoC（3）——拓扑指标

目录 一、概述 二、指标 2.1 与网络流量无关的指标 2.1.1 度&#xff08;degree&#xff09; 2.1.2 对分带宽&#xff08;bisection bandwidth&#xff09; 2.1.3 网络直径&#xff08;diameter&#xff09; 2.2 与网络流量相关的指标 2.2.1 跳数&#xff08;hop coun…
阅读更多...
【51单片机】初学者必读的一文【探究定时计数器与中断系统是如何配合起来的？】（9）

【51单片机】初学者必读的一文【探究定时计数器与中断系统是如何配合起来的？】（9）

前言 大家好吖&#xff0c;欢迎来到 YY 滴单片机系列 &#xff0c;热烈欢迎&#xff01; 本章主要内容面向接触过单片机的老铁 主要内容含&#xff1a; 欢迎订阅 YY滴C专栏&#xff01;更多干货持续更新&#xff01;以下是传送门&#xff01; YY的《C》专栏YY的《C11》专栏YY的…
阅读更多...
Nvidia 推出了本地版聊天 Chat with RTX；OpenAI联创Karpathy宣布离职专注个人项目

Nvidia 推出了本地版聊天 Chat with RTX；OpenAI联创Karpathy宣布离职专注个人项目

&#x1f989; AI新闻 Nvidia 推出了本地版聊天 Chat with RTX 摘要&#xff1a;英伟达最近发布了名为“Chat with RTX”的Demo版个性化AI聊天机器人&#xff0c;适用于Windows平台&#xff0c;需要Nvidia的30系/40系显卡&#xff0c;显存至少为8GB&#xff0c;系统配置包括1…
阅读更多...
【C++关联式容器】unordered_set

【C++关联式容器】unordered_set

目录 unordered_set 1. 关联式容器额外的类型别名 2. 哈希桶 3. 无序容器对关键字类型的要求 4. Member functions 4.1 constructor、destructor、operator 4.1.1 constructor 4.1.2 destructor 4.1.3 operator 4.2 Capacity ​4.2.1 empty 4.2.2 size 4.2.3 max…
阅读更多...
Rust - 切片Slice

Rust - 切片Slice

Slice类型 Slice数据类型没有所有权&#xff0c;slice允许我们引用集合中一段连续的元素序列而不用引用整个集合。字符串slice(string slice) 是String中 一部分值的引用。如下述代码示例&#xff0c;不是对整个String的引用而是对部分String的引用&#xff1a; fn main() {l…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023