游戏开发中双缓冲解决屏幕闪烁问题
游戏功能:
1.在点击鼠标时,可以在相应的位置显示棋子
2.可以自动判断游戏是否结束<哪方胜利>.
3.对游戏时间进行设置(单位为分钟),判断玩家是否超出设定时间.超时者失败.
4.玩家可在游戏结束前认输.
开发流程：
开发游戏界面.
系统的游戏界面依靠背景图片处理,在窗体中显示图片的方法:
创建背景图片对象
// 背景图片
BufferedImage bgImage = null;
初始化图片代码
try {
bgImage = ImageIO.read(new File("/images/bkground.jpg"));
} catch (IOException e) {
e.printStackTrace();
}
初重写paint(Graphics gc)方法,在该方法中加入如下代码:
g.drawImage(bgImage, 0, 25, this);
解决窗口显示未加载问题
this.repaint();
计算期盼中每条线的间距:用19*19的围棋棋盘.
总宽度为360像素分成18分.每份20像素.
// 画棋盘<19*19的围棋棋盘>
for (int i = 0; i < 19; i++) {
// 画横线时,横坐标不变,两个点的纵坐标每次增加20个像素
g.drawLine(10, 75 + 20 * i, 370, 75 + 20 * i);
// 画竖线,纵坐标不变,两个点的横坐标每次增加20个像素
g.drawLine(10 + 20 * i, 75, 10 + 20 * i, 435);
}
// 标注棋盘上的点位
g.fillOval(68, 133, 4, 4);
g.fillOval(308, 133, 4, 4);
g.fillOval(308, 373, 4, 4);
g.fillOval(68, 373, 4, 4);
g.fillOval(188, 133, 4, 4);
g.fillOval(68, 253, 4, 4);
g.fillOval(188, 373, 4, 4);
g.fillOval(308, 253, 4, 4);
g.fillOval(188, 253, 4, 4);
在棋盘上相应位置落子
黑子：一个实心的空圆表示
白字: 一个空心的黑圆+一个实心的白圆表示
// 绘制棋子
for (int i = 0; i < 19; i++) {
for (int j = 0; j < 19; j++) {
// 10为棋盘最左边的线条距离窗体的边距为10像素.20为线条之间的宽度
int tempX = i * 20 + 10;
// 75为棋盘最上边的线条距离窗体的边距为75像素.20为线条之间的宽度
int tempY = j * 20 + 15;
if (allChess[i][j] == 1) {// 如果当前落子条件为黑棋
// 绘制黑色实心圆
g.fillOval(tempX - 7, tempY - 7, 16, 16);
}
if (allChess[i][j] == 2) {// 如果当前落子条件为白棋
// 绘制白色空心圆
g.setColor(Color.WHITE);
g.fillOval(tempX - 7, tempY - 7, 16, 16);
g.setColor(Color.BLACK);
// 绘制空心黑圆给白子加边框
g.drawOval(tempX - 7, tempY - 7, 16, 16);
}
}
}
repaint()方法:重新执行一次paint()方法.
保存之前下过的所有棋子
定义19* 19二维数组
// 数组中的内容为0表示没有棋子,为1表示为黑子,为2表示为白子.
int[][] allChess = new int[19][19];
判断胜负
依据五子棋的基本游戏规则,判断是否有同一颜色的棋子连成5个.
五子棋核心算法
private boolean checkWin() {
boolean flag = false;
int color = allChess[x][y];
// 判断横向是否有5个相连的棋子
int i1 = 1; // i为步进变量
int count1 = 1; // count用来统计棋子个数
/** 左 ———>右 */
while (color == allChess[x + i1][y]) {// 横向向右判断
count1++;
i1++;
}
i1 = 1;
/** 右 ———>左 */
while (color == allChess[x - i1][y]) {// 横向向左判断
count1++;
i1++;
}
if (count1 >= 5) {
flag = true;
}
// 判断纵向是否有5个相连的棋子
int count2 = 1;
int i2 = 1;
/** 上———>下 */
while (color == allChess[x][y + i2]) {
count2++;
i2++;
}
i2 = 1;
/** 下———>上 */
while (color == allChess[x][y - i2]) {
count2++;
i2++;
}
if (count2 >= 5) {
flag = true;
}
// 判断左斜向是否有5个相连的棋子
int count3 = 1;
int i3 = 1;
/** 左上———>右下 */
while (color == allChess[x + i3][y + i3]) {
count3++;
i3++;
}
i3 = 1;
/** 右下———>左上 */
while (color == allChess[x - i3][y - i3]) {
count3++;
i3++;
}
if (count3 >= 5) {
flag = true;
}
// 判断右斜向是否有5个相连的棋子
int count4 = 1;
int i4 = 1;
/** 左下———>右上 */
while (color == allChess[x + i4][y - i4]) {
count4++;
i4++;
}
i4 = 1;
/** 右上———>左下 */
while (color == allChess[x - i4][y + i4]) {
count4++;
i4++;
}
if (count4 >= 5) {
flag = true;
}
// }
return flag;
}
上面的算法可以实现,但是重复代码太多需要改进.
private int checkCount(int xChange, int yChange, int color) {
int count = 1;
int tempX = xChange;
int tempY = yChange;
while ((x + xChange >= 0) && (x + xChange <= 18) && (y + yChange >= 0)
&& (y + yChange <= 18)
&& (color == allChess[x + xChange][y + yChange])) {
count++;
if (xChange != 0) {
xChange++;
}
if (yChange != 0) {
if (yChange > 0) {
yChange++;
} else {
yChange--;
}
}
}
xChange = tempX;
yChange = tempY;
while ((x - xChange >= 0) && (x - xChange <= 18) && (y - yChange >= 0)
&& (y - yChange <= 18)
&& (color == allChess[x - xChange][y - yChange])) {
count++;
if (xChange != 0) {
xChange++;
}
if (yChange != 0) {
if (yChange > 0) {
yChange++;
} else {
yChange--;
}
}
}
return count;
}
处理屏幕闪烁问题
双缓冲技术:用在手机游戏中最多,原因是手机内存相对较小,闪烁问题比较明显
public void paint(Graphics gc) {
// 雙緩衝技術,解決屏幕閃爍問題
BufferedImage bi = new BufferedImage(500, 500,
BufferedImage.TYPE_INT_ARGB);
Graphics g = bi.createGraphics();
g.setColor(Color.BLACK);
// 绘制背景
g.drawImage(bgImage, 0, 25, this);
// 输出标题信息
g.setFont(new Font("黑体", Font.BOLD, 20));
g.drawString("游戏信息: " + message, 130, 65);
// 输出时间信息
g.setFont(new Font("宋体", Font.PLAIN, 14));
g.drawString("黑方时间: " + blackMessage, 30, 475);
g.drawString("白方时间: " + whiteMessage, 260, 475);
// 画棋盘<19*19的围棋棋盘>
for (int i = 0; i < 19; i++) {
// 画横线时,横坐标不变,两个点的纵坐标每次增加20个像素
g.drawLine(10, 75 + 20 * i, 370, 75 + 20 * i);
// 画竖线,纵坐标不变,两个点的横坐标每次增加20个像素
g.drawLine(10 + 20 * i, 75, 10 + 20 * i, 435);
}
// 标注棋盘上的点位
g.fillOval(68, 133, 4, 4);
g.fillOval(308, 133, 4, 4);
g.fillOval(308, 373, 4, 4);
g.fillOval(68, 373, 4, 4);
g.fillOval(188, 133, 4, 4);
g.fillOval(68, 253, 4, 4);
g.fillOval(188, 373, 4, 4);
g.fillOval(308, 253, 4, 4);
g.fillOval(188, 253, 4, 4);
// 绘制棋子
for (int i = 0; i < 19; i++) {
for (int j = 0; j < 19; j++) {
// 10为棋盘最左边的线条距离窗体的边距为10像素.20为线条之间的宽度
int tempX = i * 20 + 10;
// 75为棋盘最上边的线条距离窗体的边距为75像素.20为线条之间的宽度
int tempY = j * 20 + 15;
if (allChess[i][j] == 1) {// 如果当前落子条件为黑棋
// 绘制黑色实心圆
g.fillOval(tempX - 7, tempY - 7, 16, 16);
}
if (allChess[i][j] == 2) {// 如果当前落子条件为白棋
// 绘制白色空心圆
g.setColor(Color.WHITE);
g.fillOval(tempX - 7, tempY - 7, 16, 16);
g.setColor(Color.BLACK);
// 绘制空心黑圆给白子加边框
g.drawOval(tempX - 7, tempY - 7, 16, 16);
}
}
}
gc.drawImage(bi, 0, 0, this);
}
实现各个按钮的功能
开始游戏:从新开始游戏
游戏设置:设置游戏倒计时
游戏说明:用来说明游戏规则和操作
认输:表示某一方放弃游戏,投子认负
关于:用来显示程序的作者或者编写单位的相关说明
退出:退出游戏
游戏代码
package org.avlispu.game.frame;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
/**
*
* @author 苏若年 <a href='dennisit@163.com'> Email:dennisit@163.com</a>
*
* @verson 1.0
*
* @create time:2012-1-15 2012-1-15
*
* @TODO
*
*/
public class FiveChessFrame extends JFrame implements MouseListener, Runnable {
// 获取屏幕宽度
int width = Toolkit.getDefaultToolkit().getScreenSize().width;
// 获取屏幕高度
int height = Toolkit.getDefaultToolkit().getScreenSize().height;
// 背景图片
BufferedImage bgImage = null;
// x,y用来保存棋子落下的坐标
int x = 0, y = 0;
// 保存之前下过的全部棋子的坐标,
// 数组中的内容为0表示没有棋子,为1表示为黑子,为2表示为白子.
int[][] allChess = new int[19][19];
// 定义一个标记表示当前应该黑棋还是白棋下下一步
boolean isBlack = true;
// 标识当前游戏是否可以继续
boolean canPlay = true;
// 顯示提示信息
String message = "黑方先行";
// 保存最多拥有多少时间(秒)
int maxTime = 0;
// 应用线程类做倒计时。
Thread thread = null;
// 保存黑方与白方的剩余时间
int blackTime = 0;
int whiteTime = 0;
// 保存双方剩余时间的现实信息
String blackMessage = "无限制.";
String whiteMessage = "无限制.";
// 定义当前 线程是否运行的标志
boolean flagThread = false;
/**
* 构造方法
*/
public FiveChessFrame() {
//初始化界面
init();
// 构建对象时启动线程,并将线程挂起.
thread.start();
// 挂起线程
thread.suspend();
}
/**
* 初始化界面的方法
*/
public void init() {
// 设置标题
this.setTitle("五子棋");
// 设置窗体的大小
this.setSize(500, 500);
// 设置窗体出现的位置
this.setLocation((width - 500) / 2, (height - 500) / 2);
// 设置窗体的大小为不可变
this.setResizable(false);
// 设置窗体的关闭方式为默认关闭后程序结束
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 为窗体添加监听器
this.addMouseListener(this);
// 设置窗体可以显示出来
this.setVisible(true);
thread = new Thread(this);
// 初始化图片
try {
bgImage = ImageIO.read(new File("images/bkground.jpg"));
} catch (IOException e) {
e.printStackTrace();
}
//在创建窗体时,重新绘制一边,以解决窗体初始显示的未加载问题.
this.repaint();
}
/**
* 覆写paint()方法,绘制背景,棋盘、棋子
*/
public void paint(Graphics gc) {
// 双缓冲技术,解决屏幕闪烁问题.
BufferedImage bi = new BufferedImage(500, 500,
BufferedImage.TYPE_INT_ARGB);
Graphics g = bi.createGraphics();
// 绘制背景
g.drawImage(bgImage, 0, 20, this);
// 输出标题信息
g.setColor(Color.BLACK);
g.setFont(new Font("黑体", Font.BOLD, 20));
g.drawString("游戏信息: " + message, 130, 65);
// 输出时间信息
g.setFont(new Font("宋体", Font.PLAIN, 14));
g.drawString("黑方时间: " + blackMessage, 30, 475);
g.drawString("白方时间: " + whiteMessage, 260, 475);
// 画棋盘<19*19的围棋棋盘>
for (int i = 0; i < 19; i++) {
// 画横线时,横坐标不变,两个点的纵坐标每次增加20个像素
g.drawLine(10, 75 + 20 * i, 370, 75 + 20 * i);
// 画竖线,纵坐标不变,两个点的横坐标每次增加20个像素
g.drawLine(10 + 20 * i, 75, 10 + 20 * i, 435);
}
// 标注棋盘上的点位
g.fillOval(68, 133, 4, 4);
g.fillOval(308, 133, 4, 4);
g.fillOval(308, 373, 4, 4);
g.fillOval(68, 373, 4, 4);
g.fillOval(188, 133, 4, 4);
g.fillOval(68, 253, 4, 4);
g.fillOval(188, 373, 4, 4);
g.fillOval(308, 253, 4, 4);
g.fillOval(188, 253, 4, 4);
// 绘制棋子
for (int i = 0; i < 19; i++) {
for (int j = 0; j < 19; j++) {
// 10为棋盘最左边的线条距离窗体的边距为10像素.20为线条之间的宽度
int tempX = i * 20 + 11;
//75为棋盘最上边的线条距离窗体的边距为75像素.20为线条之间的宽度
int tempY = j * 20 + 76;
if (allChess[i][j] == 1) {// 如果当前落子条件为黑棋
// 绘制黑色实心圆
g.fillOval(tempX - 7, tempY - 7, 16, 16);
}
if (allChess[i][j] == 2) {// 如果当前落子条件为白棋
// 绘制白色空心圆
g.setColor(Color.WHITE);
g.fillOval(tempX - 7, tempY - 7, 16, 16);
g.setColor(Color.BLACK);
// 绘制空心黑圆给白子加边框
g.drawOval(tempX - 7, tempY - 7, 16, 16);
}
}
}
//双缓冲技术的应用.
gc.drawImage(bi, 0, 0, this);
}
/**
* 鼠标按下的方法
*/
@Override
public void mousePressed(MouseEvent e) {
// 获取鼠标按下的x坐标
x = e.getX();
// 获取鼠标按下的y坐标
y = e.getY();
// 如果落子在棋盘范围之内<x(10,370), y(75,435)为了边界下棋,在边界处范围增加5像素>
if (x >= 5 && x <= 375 && y >= 68 && y <= 442) {
if (canPlay == true) {
// 使用算法判断鼠标点击处距离哪个交叉点最近,
x = (x - 11) / 20;
y = (y - 76) / 20;
// 如果当前位置没有棋子
if (allChess[x][y] == 0) {
// 判断下的棋子的颜色
if (isBlack == true) {// 如果为黑棋走子
allChess[x][y] = 1;
isBlack = false;
message = "轮到白方";
} else {// 如果为白棋走子
allChess[x][y] = 2;
isBlack = true;
message = "轮到黑方";
}
// 使用repaint方法表示重新执行一次paint()方法实现棋子绘制的调用
this.repaint();
// 判断该子是否其其他同色子连成5连,即判断游戏是否结束
boolean winFlag = this.checkWin();
if (winFlag) {
String win = (allChess[x][y] == 1 ? "黑方" : "白方") + "获胜";
message = win;
this.repaint();
canPlay = false;
JOptionPane.showMessageDialog(this, "游戏结束:" + win);
}
}/*
* else { JOptionPane.showMessageDialog(this,
* "当前位置已经有棋子,请重新落子"); }
*/
} else {
JOptionPane.showMessageDialog(this, "游戏已经结束!");
}
}
// 如果鼠标落在开始按钮区
if (x >= 397 && x <= 471 && y >= 117 && y <= 146) {
int result = JOptionPane.showConfirmDialog(this, "确认要重新开始游戏?");
if (0 == result) {
// 确认重新开始
allChess = new int[19][19]; // 清除棋盘上所有棋子
message = "黑方先行"; // 回复提示消息为最初状态
isBlack = true; // 设置初始为黑棋先下
canPlay = true; // 初始到默认可以下子状态
blackMessage = "无限制.";
whiteMessage = "无限制.";
if (flagThread) {
thread.suspend();
flagThread = false;
}
thread = new Thread(this);
thread.start();
thread.suspend();
this.repaint(); // 重新绘制棋盘
}
}
// 如果鼠标落在游戏设置按钮区
if (x >= 397 && x <= 471 && y >= 160 && y <= 188) {
String info = "请输入游戏游戏的最大时间(单位:分钟)" + "\n如果输入数字为0表示没有时间限制:";
String input = JOptionPane.showInputDialog(info);
if (input.matches("\\d+")) {
maxTime = Integer.parseInt(input) * 60;
if (maxTime == 0) {
blackMessage = "无限制.";
whiteMessage = "无限制.";
if (flagThread) {
thread.suspend();
flagThread = false;
}
} else {
blackTime = maxTime;
whiteTime = maxTime;
flagThread = true;
thread.resume();
}
int result = JOptionPane.showConfirmDialog(this,
"设置完成,是否重新开始游戏");
if (0 == result) {
// 确认重新开始
allChess = new int[19][19]; // 清除棋盘上所有棋子
message = "黑方先行"; // 回复提示消息为最初状态
isBlack = true; // 设置初始为黑棋先下
canPlay = true; // 初始到默认可以下子状态
}
this.repaint();
} else {
JOptionPane.showMessageDialog(this, "请输入正确的参数.");
}
}
// 如果鼠标落在游戏说明按钮区
if (x >= 397 && x <= 471 && y >= 204 && y <= 234) {
String info = "\n游戏说明:" + "\n |-- 单击版\"五子棋无敌手\""
+ "\n |-- 游戏采用双人对战模式" + "\n |-- 点击设置设置游戏时间";
JOptionPane.showMessageDialog(this, info);
}
// 如果鼠标落在认输按钮区
if (x >= 397 && x <= 471 && y >= 232 && y <= 321) {
int result = JOptionPane.showConfirmDialog(this, "确认要认输吗?");
if (0 == result) {// 如果认输
if (isBlack == true) {
// 如果当前为黑棋下子状态
message = "黑棋认输";
this.repaint();
JOptionPane.showMessageDialog(this, "黑棋认输,游戏结束!");
} else {
message = "白棋认输";
this.repaint();
JOptionPane.showMessageDialog(this, "白棋认输,游戏结束!");
}
// 游戏结束,不能再下子
canPlay = false;
}
}
// 如果鼠标落在关于按钮区
if (x >= 397 && x <= 471 && y >= 336 && y <= 364) {
String info = "\n游戏 : \"五子棋无敌手\" " + "\n |-- 作者 : 墨少白"
+ "\n |-- Q Q : 799089378" + "\n |-- 邮箱 : Alivspu@163.com";
JOptionPane.showMessageDialog(this, info);
}
// 如果鼠标落在退出按钮区
if (x >= 397 && x <= 471 && y >= 384 && y <= 415) {
String info = "\n应用提示" + "\n --- 系统退出 ---";
JOptionPane.showMessageDialog(this, info);
System.exit(0);
}
}
/**
* 五子棋输赢判断的核心算法
*
* @return
*/
private boolean checkWin() {
boolean flag = false;
int color = allChess[x][y];
// 判断横向
int count = checkCount(1, 0, color);
if (count >= 5) {
flag = true;
} else {
// 判读纵向
count = checkCount(0, 1, color);
if (count >= 5) {
flag = true;
} else {
// 判读左下<-->右上方向
count = checkCount(1, -1, color);
if (count >= 5) {
flag = true;
} else {
// 判读左上<-->右下方向
count = checkCount(1, 1, color);
if (count >= 5) {
flag = true;
}
}
}
}
return flag;
}
/**
* 计算与当前落子颜色相同的相连棋子数目
*
* @param xChange棋子x方向的步进量
* @param yChange棋子y方向的步进量
* @param color
* 当前落子的颜色
* @return
*/
private int checkCount(int xChange, int yChange, int color) {
int count = 1;
int tempX = xChange;
int tempY = yChange;
while ((x + xChange >= 0) && (x + xChange <= 18) && (y + yChange >= 0)
&& (y + yChange <= 18)
&& (color == allChess[x + xChange][y + yChange])) {
count++;
if (xChange != 0) {
xChange++;
}
if (yChange != 0) {
if (yChange > 0) {
yChange++;
} else {
yChange--;
}
}
}
xChange = tempX;
yChange = tempY;
while ((x - xChange >= 0) && (x - xChange <= 18) && (y - yChange >= 0)
&& (y - yChange <= 18)
&& (color == allChess[x - xChange][y - yChange])) {
count++;
if (xChange != 0) {
xChange++;
}
if (yChange != 0) {
if (yChange > 0) {
yChange++;
} else {
yChange--;
}
}
}
return count;
}
/**
* 覆写Runnable中的run()方法.实现时间变化
*/
@Override
public void run() {
if (blackTime > 0 || whiteTime > 0) {
if (flagThread) {
while (true) {
if (isBlack == true && canPlay == true) {
// 如果当前为黑棋下子状态
blackTime--;
if (blackTime < 0) {
message = "黑方超时";
canPlay = false;
this.repaint();
JOptionPane.showMessageDialog(this, "黑方超时,游戏结束");
break;
}
} else if (isBlack != true && canPlay == true) {
// 如果当前为白棋下子状态
whiteTime--;
if (whiteTime < 0) {
message = "白方超时";
canPlay = false;
this.repaint();
JOptionPane.showMessageDialog(this, "白方超时,游戏结束");
break;
}
} else {
break;
}
blackMessage = blackTime / 3600 + ":"
+ (blackTime / 60 - blackTime / 3600 * 60) + ":"
+ blackTime % 60;
whiteMessage = whiteTime / 3600 + ":"
+ (whiteTime / 60 - whiteTime / 3600 * 60) + ":"
+ whiteTime % 60;
try {
Thread.sleep(1000);// 睡眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
this.repaint();
}
} else {
blackMessage = "无限制.";
whiteMessage = "无限制.";
this.repaint();
}
}
}
@Override
public void mouseClicked(MouseEvent e) {
System.out.println("鼠标单击,当前鼠标的位置为:<"+e.getX()+","+e.getY()+">");
}
@Override
public void mouseReleased(MouseEvent e) {
System.out.println("鼠标松开");
}
@Override
public void mouseEntered(MouseEvent e) {
System.out.println("鼠标进入");
}
@Override
public void mouseExited(MouseEvent e) {
System.out.println("鼠标离开");
}
}
主方法
package org.avlispu.game.main;
import org.avlispu.game.frame.FiveChessFrame;
/**
*
* @author 苏若年 <a href='dennisit@163.com'> Email:dennisit@163.com</a>
*
* @verson 1.0
*
* @create time:2012-1-15 2012-1-15
*
* @TODO
*
*/
public class FiveChess {
public static void main(String[] args) {
FiveChessFrame mf = new FiveChessFrame();
}
}
转载请注明出处:[http://www.cnblogs.com/dennisit/archive/2013/02/16/2913279.html]
热爱生活,热爱Coding,敢于挑战,用于探索 ...
