开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Java编程 > Applet > 游戏 > 查看源码
Model.java
资源名称：lianliankan.rar　[点击查看]
上传用户：jennyfly
上传日期：2021-08-10
资源大小：735k
文件大小：45k
源码类别：

游戏

开发平台：

Java

Model.java：源码内容
  1. package model;
  3. import java.awt.Color;
  4. import java.awt.Point;
  5. import java.awt.Rectangle;
  6. import java.util.ArrayList;
  7. import java.util.Observable;
  8. import java.util.Random;
  10. import view.Sound;
  12. /**
  13.  * model控制所有数据操作和逻辑操作
  14.  * 
  15.  * @author 何晓飞
  16.  * @version 2.0
  17.  */
  18. public class Model extends Observable implements Runnable {
  19. public static final int PIC_SUITS=2;
  20. /*统一的背景色*/
  21. public static final Color BG_COLOR=new Color(186,120,168);
  22. /* 要导进游戏界面的图片的对数 */
  23. public static final int CARD_PAIRS = 70;
  24. /* 总关数 */
  25. public static final int TOTAL_LEVEL = 10;
  26. /* 默认的剩余时间 */
  27. private static final int DEFAULT_TIME = 400;
  28. /* 默认的历史记录 */
  29. private static final int DEFAULT_RECORD = 999;
  30. /*默认背景音乐*/
  31. private static final String DEFAULT_MUSIC="我心永恒.mid";
  32. /*默认图片文件夹*/
  33. private static final String DEFAULT_PIC_FILE="fruit";
  34. /*总提示数*/
  35. private static final int TOTAL_REMIND = 8;
  36. /* 每个单元的宽度 */
  37. private final int cellWidth;
  38. /* 每个单元的高度 */
  39. private final int cellHeight;
  40. /* 单元之间的边框距离 */
  41. private final int cellBorder;
  42. /* 总行数 */
  43. private final int rows;
  44. /* 总列数 */
  45. private final int cols;
  46. /* 要导进游戏界面的每一类图片的总数 */
  47. private int pictureNumbers;
  48. /* 关数 */
  49. private int level;
  50. /*给每个关一个个性化的名字*/
  51. private String levelName;
  52. /* 通关时的分数，这个数据作为保存游戏时的一个部分 */
  53. private int lastScore;
  54. /* 当前分数 */
  55. private int currentScore;
  56. /*演示开始时的得分*/
  57. private int demoScore;
  58. /* 当前关数游戏时间 */
  59. private int playTime;
  60. /* 剩余时间 */
  61. private int timeLeft;
  62. /* 每一关对应的给定过关时间 */
  63. private int timeGiven;
  64. /* 被标记为选中单元的点 */
  65. private Point cellSelected;
  66. /* 存储路径总的关键点 */
  67. private ArrayList<Point> keyPoints;
  68. /* 纪录拐弯时的图片所对应的点的信息 */
  69. private Point corner1, corner2;
  71. /* 游戏当前关数的开始时间 */
  72. public long startTime;
  73. /* 暂停时的时间 */
  74. public long pauseTime;
  75. /* 当前关数总共暂停了的时间 */
  76. public int pauseDuration;
  77. /* 剩余的图片数量 */
  78. private int cardLeft;
  79. /* 从文件中读取的历史纪录集 */
  80. private ArrayList<Record> records;
  82. /* 该线程用于定时的对界面进行更新功能 */
  83. private Thread autoTimer;
  85. /* 该线程用于示范功能 */
  86. private Thread demoThread;
  88. /* 是否处在演示模式的标志 */
  89. public boolean IsDemo = false;
  91. /* 游戏是否进行中 */
  92. public boolean IsPlaying = true;
  94. /* 所选图片种类的文件夹名字 */
  95. private String pictureFile;
  97. /* 总提示机会 */
  98. private int reminds;
  99. /*演示开始时的提示机会*/
  100. private int demoReminds;
  101. /* 所选音乐 */
  102. private String music;
  104. /* 点击声音 */
  105. private Sound clickSound;
  107. /* 连时声音 */
  108. private Sound linkSound;
  109. /* 过关声音 */
  110. private Sound passSound;
  112. /* 纪录窗体位置 */
  113. private Point frameLocation = null;
  114. /* 建立一个数组，用于记录每个单元的信息 */
  115. private int[][] data;
  117. /**
  118.  * 初始化各参数
  119.  */
  120. public Model() {
  121. /*
  122.  * 初始化单元长宽，边框，总行数和列数
  123.  */
  124. cellWidth = 40;
  125. cellHeight = 40;
  126. cellBorder = 1;
  127. rows = 12;
  128. cols = 20;
  129. data = new int[rows][cols];
  130. records = new ArrayList<Record>();// 初始化历史记录集
  131. pictureFile = DEFAULT_PIC_FILE; // 设置游戏界面所用图片
  132. music = DEFAULT_MUSIC; // 初始化音乐
  133. pictureNumbers = 30;// 设置游戏界面所用图片数量
  134. clickSound = new Sound("click.wav");// 建立点击声音的对象
  135. linkSound = new Sound("delete.wav");// 建立连时声音的对象
  136. passSound = new Sound("pass.wav");// 建立过关时声音的对象
  137. reminds=TOTAL_REMIND;
  138. level = 1;// 设置关数
  139. lastScore = 0;// 作为记录的得分
  140. currentScore = 0;// 当前得分
  141. pauseDuration = 0;// 初始化暂停总时间
  142. timeLeft = DEFAULT_TIME;// 初始化剩余时间
  143. cellSelected = null;
  144. keyPoints = new ArrayList<Point>();
  145. /*
  146.  * 初始化窗口设置
  147.  */
  148. loadSet();
  149. /*
  150.  * 初始化历史记录集
  151.  */
  152. loadRecord();
  153. }
  155. /**
  156.  * 帮助
  157.  */
  158. public void about() {
  159. notifyAbout();
  160. }
  162. public void back(){
  163. notifyBack();
  164. }
  166. /**
  167.  * 退出
  168.  */
  169. public void cancel() {
  170. notifyCancel();
  171. }
  173. /**
  174.  * 假如取消单击右键的话，调用此方法已取消当前的选择
  175.  */
  176. public void cancelSelect() {
  177. cellSelected = null;
  178. paintPic();
  179. }
  181. /**
  182.  * 判断两个位置的图片是否可以消去
  183.  * 
  184.  * @param p1
  185.  *            第一个位置
  186.  * @param p2
  187.  *            第二个位置
  188.  * @return 是否可以消去的boolean 结果
  189.  */
  190. private boolean canDelete(Point p1, Point p2) {
  191. // 初级的判断是否可连(包括位置一样的不能连,位置上的图片不一样,位置上的图片为空)
  192. // 这些是最基本的判断,要不满足就直接返回False
  193. if (p1.equals(p2) || data[p1.x][p1.y] != data[p2.x][p2.y]
  194. || data[p1.x][p1.y] == 0 || data[p2.x][p2.y] == 0)
  195. return false;
  196. corner1 = null;//
  197. corner2 = null;//
  198. // 高级的判断是否可连(包括直线连,有一个弯连,有两个弯连)
  199. // 可连的判断
  200. if (noCorner(p1, p2) || oneCorner(p1, p2) || twoCorner(p1, p2))
  201. return true;
  202. else
  203. return false;
  204. }
  206. /**
  207.  * 当监听MouseEvent事件的话，进行各种情况的判断以知道是否可连
  208.  * 
  209.  * @param p
  210.  *            所点的图片对应的Point对象
  211.  */
  212. public void clickCell(Point p) {
  213. /*
  214.  * 如果越界或者坐标点所表示的图像为空或者处于演示模式则返回
  215.  */
  216. if (isEmpty(p) || (!withinBound(p))||IsDemo)
  217. return;
  218. else {
  219. /*
  220.  * 判断是否已经有被选中的单元了，若没有则将所给元素设为被选中单元 并且播放点击音乐
  221.  */
  222. if (null == cellSelected) {
  223. cellSelected = p;
  224. clickSound.play(false);
  225. }
  226. /*
  227.  * 如果在此之前被选中单元已经有值了，那么判断给定的图片是否能与该 选中单元相消，如果可以则执行消去方法并被选单元置空以重新被赋值
  228.  */
  229. else if (canDelete(cellSelected, p)) {
  230. delete(cellSelected, p, true);
  231. cellSelected = null;
  232. /*
  233.  * 每一次消去都可能导致图片消完因此要进行判断是否消完
  234.  */
  235. if (cardLeft == 0) {
  236. IsPlaying=false;
  237. passSound.play(false);
  238. // 纪录时间
  239. if (getPlayTime() < getRecord(level)) {//判断是否你打破了纪录，如果你打破了纪录
  240. // ，
  241. // 将会让你只知道
  242. LoadAndSave.saveRecord(getLevel(), getPlayTime()); // ，
  243. // 并将这个新的纪录写入文件
  244. notifyBreakRecord();
  245. }
  246. if (!IsDemo) {
  247. if (level < TOTAL_LEVEL) {
  248. if (getPlayTime() < getTimeGiven()) {
  249. int scoreAdd = 0;
  250. scoreAdd += (getTimeGiven() - getPlayTime()) * 5;
  251. currentScore += scoreAdd;
  252. }
  253. setLastScore(currentScore);
  254. level++;
  255. } else {
  256. notifyAccomplish();
  257. notifyOption();
  258. }
  259. }
  260. notifyLevel();// 刷新关数
  261. notifyRecord();// 刷新分数
  262. startGame(true);// 重新开始
  263. }
  264. /*
  265.  * 也有可能导致死锁
  266.  */
  267. if (cardLeft > 2 && solutionCount() == 0) {
  268. notifyNoSolution();
  269. refresh();
  270. }
  271. }
  272. /**
  273.  * 如果不能消去，那么被选单元的值被给定点替换掉，等待与下一个点匹 配，同时播放点击音乐
  274.  */
  275. else {
  276. cellSelected = p;
  277. clickSound.play(false);
  278. }
  279. paintPic();// 刷新
  280. }
  281. }
  283. /**
  284.  * 点击音乐按钮
  285.  */
  286. public void clickMusic() {
  287. notifyClickMusic();
  288. }
  290. /**
  291.  * 选择图片
  292.  */
  293. public void clickPic() {
  294. notifyClickPic();
  295. }
  297. /**
  298.  * 点击声音开关
  299.  */
  300. public void clickSound() {
  301. notifyClickSound();
  302. }
  304. /**
  305.  * 相消
  306.  * 
  307.  * @param Point
  308.  *            ,Point,boolean p1, p2前后所点的两个点,第三个参数能表明是相消还是提示
  309.  */
  310. private void delete(Point p1, final Point p2, boolean bDelete) {
  311. /*
  312.  * corner1 为空那么corner2必然为空 此时只需要加上两个连接点
  313.  */
  314. if (corner1 == null) {
  316. keyPoints.add(p1);
  317. keyPoints.add(p2);
  319. }
  320. /*
  321.  * corner1不为空而corner2为空这样可以判断为一个弯的情况，这样加上两个连接点和第一个转角
  322.  */
  323. else if (corner1 != null && corner2 == null) {
  324. keyPoints.add(p1);
  325. keyPoints.add(corner1);
  326. keyPoints.add(p2);
  328. }
  329. /*
  330.  * corner2 不为空，则corner1必然不为空，这样的话，连接的时候需要加上两个连接点和两个转角
  331.  */
  332. else if (corner2 != null) {
  334. if (p1.x != corner1.x && p1.y != corner1.y) {
  335. Point pt = corner1;
  336. corner1 = corner2;
  337. corner2 = pt;
  338. }
  339. keyPoints.add(p1);
  340. keyPoints.add(corner1);
  341. keyPoints.add(corner2);
  342. keyPoints.add(p2);
  344. }
  345. notifyLink();
  346. // bDelete其实就是判断它是在给你提示，还是你要真正的连
  347. if (bDelete) {
  348. // 根据level来判断连完图片后其他图片应该做怎样的调整，下面是那10关的调用
  349. switch (level) {
  350. case 1:
  351. level1(p1, p2);
  352. break;
  353. case 2:
  354. level2(p1, p2);
  355. break;
  356. case 3:
  357. level3(p1, p2);
  358. break;
  359. case 4:
  360. level4(p1, p2);
  361. break;
  362. case 5:
  363. level5(p1, p2);
  364. break;
  365. case 6:
  366. level6(p1, p2);
  367. break;
  368. case 7:
  369. level7(p1, p2);
  370. break;
  371. case 8:
  372. level8(p1, p2);
  373. break;
  374. case 9:
  375. level9(p1, p2);
  376. break;
  377. case 10:
  378. level10(p1, p2);
  379. break;
  380. default:
  381. break;
  382. }
  383. }
  384. }
  386. /**
  387.  * 演示
  388.  */
  389. public void demo() {
  390. notifyDemo();
  391. }
  393. /**
  394.  * 进入游戏
  395.  */
  396. public void enter() {
  397. notifyEnter();
  398. }
  400. /**
  401.  * 释放关键点
  402.  */
  403. public void freeKeyPoints() {
  404. keyPoints.clear();
  405. }
  407. /**
  408.  * 获取剩余图片数
  409.  * 
  410.  * @return 剩余图片数目
  411.  */
  412. public int getCardLeft() {
  413. return this.cardLeft;
  414. }
  416. /**
  417.  * 获取单元间距
  418.  * 
  419.  * @return 单元间距
  420.  */
  421. public int getCellBorder() {
  422. return this.cellBorder;
  423. }
  425. /**
  426.  * 获取单元格高度
  427.  * 
  428.  * @return 单元高度
  429.  */
  430. public int getCellHeight() {
  431. return this.cellHeight;
  432. }
  434. /**
  435.  * 获取被设为选中单元的位置
  436.  * 
  437.  * @return 被设为选中单元的位置
  438.  */
  439. public Point getCellSelected() {
  440. return this.cellSelected;
  441. }
  443. /**
  444.  * 获取单元格宽度
  445.  * 
  446.  * @return 单元宽度
  447.  */
  448. public int getCellWidth() {
  449. return this.cellWidth;
  450. }
  452. /**
  453.  * 获取 Rectangle 对象的中心坐标，将其生成一个point返回.
  454.  * 
  455.  * @param rect
  456.  *            指定了坐标空间中的一个区域的Rectangle 对象.
  457.  * 
  458.  * @return Point 由参数Rectangle对象的中心坐标生成的Point对象.
  459.  */
  460. public Point getCenter(Rectangle rect) {
  461. return new Point(rect.x + rect.width / 2, rect.y + rect.height / 2);
  462. }
  463. /**
  464.  * 获取总列数
  465.  * 
  466.  * @return 总列数
  467.  */
  468. public int getCols() {
  469. return this.cols;
  470. }
  471. /**
  472.  * 获取当前分数
  473.  * 
  474.  * @return 当前分数
  475.  */
  476. public int getCurrentScore() {
  477. return this.currentScore;
  478. }
  480. /**
  481.  * 垂直的寻找，返回一个路径（包括这个路径上的所有的点）
  482.  * 
  483.  * @param p
  484.  *            原点
  485.  * @return 纵向空白点(包括与原点等值的点)
  486.  */
  487. private ArrayList<Point> getHSpaces(Point p, Point pg) {
  488. ArrayList<Point> ps = new ArrayList<Point>();
  489. // left
  490. for (int dif = 1;; dif++) {
  491. int col = p.y - dif;
  492. int row = p.x;
  493. // 向左走，如果左边的不为0且它与p2不相等，则下面if中的条件为真，退出，否则加进数祖
  494. if (col < 0
  495. || (data[row][col] != 0 && !pg.equals(new Point(row, col))))
  496. break;
  497. ps.add(new Point(row, col));
  498. }
  499. // right
  500. for (int dif = 1;; dif++) {
  501. int col = p.y + dif;
  502. int row = p.x;
  503. // 向右走，如果右边的不为0且它与p2不相等，则下面if中的条件为真，退出，否则加进数祖
  504. if (col >= cols
  505. || (data[row][col] != 0 && !pg.equals(new Point(row, col))))
  506. break;
  507. ps.add(new Point(row, col));
  508. }
  509. return ps;
  510. }
  512. /**
  513.  * 获取关键点
  514.  * @return
  515.  * 关键点
  516.  */
  517. public ArrayList<Point> getKeyPoints() {
  518. return this.keyPoints;
  519. }
  521. /**
  522.  * 获取过关时的分数
  523.  * 
  524.  * @return
  525.  */
  526. public int getLastScore() {
  527. return this.lastScore;
  528. }
  530. /**
  531.  * 获取当前关数
  532.  * 
  533.  * @return 当前关数
  534.  */
  535. public int getLevel() {
  536. return this.level;
  537. }
  539. /**
  540.  * 获取当前关数的名字
  541.  * 
  542.  * @return 当前关的名字
  543.  */
  544. public String getLevelName() {
  545. switch (level) {
  546. case 1:
  547. levelName = "初入江湖";
  548. break;
  549. case 2:
  550. levelName = "地心引力";
  551. break;
  552. case 3:
  553. levelName = "混沌初开";
  554. break;
  555. case 4:
  556. levelName = "乾坤倒转";
  557. break;
  558. case 5:
  559. levelName = "右路逢源";
  560. break;
  561. case 6:
  562. levelName = "迎风一斩";
  563. break;
  564. case 7:
  565. levelName = "左路逢源";
  566. break;
  567. case 8:
  568. levelName = "各自为政";
  569. break;
  570. case 9:
  571. levelName = "齐心协力";
  572. break;
  573. case 10:
  574. levelName = "左右交错";
  575. break;
  576. default:
  577. levelName = "未命名";
  578. break;
  579. }
  580. return levelName;
  581. }
  583. /**
  584.  * 获取窗体的位置
  585.  * 
  586.  * @return 窗体的系统坐标
  587.  */
  588. public Point getLocation() {
  589. return this.frameLocation;
  590. }
  592. /**
  593.  * @return 返回纪录图片的数组信息
  594.  */
  595. public int[][] getMaps() {
  596. return data;
  597. }
  599. /**
  600.  * 获取用户所选的音乐
  601.  * 
  602.  * @return 用户所选的音乐文件名
  603.  */
  604. public String getMusic() {
  605. return music;
  606. }
  608. /**
  609.  * 获取总暂停时间
  610.  * 
  611.  * @return 总暂停时间
  612.  */
  613. public int getPauseDuration() {
  614. return this.pauseDuration;
  615. }
  617. /**
  618.  * 获取暂停时刻
  619.  * 
  620.  * @return 暂停时刻
  621.  */
  622. public long getPauseTime() {
  623. return this.pauseTime;
  624. }
  626. /**
  627.  * 获取所用图片文件夹
  628.  * 
  629.  * @return 所用图片文件夹名
  630.  */
  631. public String getPictureFile() {
  632. return this.pictureFile;
  633. }
  635. /**
  636.  * 获取当前采用的图片总数
  637.  * 
  638.  * @return 图片总数
  639.  */
  640. public int getPictureNumber() {
  641. return this.pictureNumbers;
  642. }
  643. /**
  644.  * 获取当前关除暂停外的游戏时间
  645.  * 
  646.  * @return 除暂停外的游戏时间
  647.  */
  648. public int getPlayTime() {
  649. this.playTime = (int) (System.currentTimeMillis() - startTime) / 1000
  650. - getPauseDuration();
  651. return this.playTime;
  652. }
  654. /**
  655.  * 查询指定关的历史记录
  656.  * 
  657.  * @param level
  658.  *            记录所在关数
  659.  * @return 如果无历史记录则按默认返回否则读取历史记录返回
  660.  */
  661. public int getRecord(int entry) {
  662. /*
  663.  * 历史记录初始化为零，如果提供的level合法则遍历记录集 寻找该关的记录，如果没找到则返回默认的历史记录
  664.  */
  665. int record = 0;
  666. if (entry >= 1 && entry <= TOTAL_LEVEL) {
  667. for (Record r : records) {
  668. if (r.getLevel() == entry) {
  669. record = r.getSeconds();
  670. break;
  671. }
  672. }
  673. }
  674. if (record == 0) {
  675. record = DEFAULT_RECORD;
  676. }
  677. return record;
  678. }
  680. /**
  681.  * 获取提示次数
  682.  * 
  683.  * @return 提示次数
  684.  */
  685. public int getReminds() {
  686. return reminds;
  687. }
  689. /**
  690.  * 获取总行数
  691.  * 
  692.  * @return 总行数
  693.  */
  694. public int getRows() {
  695. return this.rows;
  696. }
  698. /**
  699.  * 获取当前关对应的给定通关时间
  700.  * 
  701.  * @return 当前关对应的给定通关时间
  702.  */
  703. public int getTimeGiven() {
  704. return this.timeGiven;
  705. }
  707. /**
  708.  * 获取当前关除去暂停后的时间剩余
  709.  * 
  710.  * @return 秒数表示的剩余时间
  711.  */
  712. public int getTimeLeft() {
  713. return this.timeLeft - getPlayTime();
  714. }
  716. /**
  717.  * 水平的寻找，返回一个路径（包括这个路径上的所有的点）
  718.  * 
  719.  * @param p
  720.  *            原点
  721.  * @return 纵向空白点(包括与原点等值的点)
  722.  */
  723. private ArrayList<Point> getVSpaces(Point p, Point pg) {
  724. ArrayList<Point> ps = new ArrayList<Point>();
  725. // left
  726. for (int dif = 1;; dif++) {
  727. int col = p.y;
  728. int row = p.x - dif;
  729. // 向上走，如果左边的不为0且它与p2不相等，则下面if中的条件为真，退出，否则加进数祖
  730. if (row < 0
  731. || (data[row][col] != 0 && !pg.equals(new Point(row, col))))
  732. break;
  733. ps.add(new Point(row, col));
  734. }
  735. // right
  736. for (int dif = 1;; dif++) {
  737. int col = p.y;
  738. int row = p.x + dif;
  739. // 向下走，如果左边的不为0且它与p2不相等，则下面if中的条件为真，退出，否则加进数祖
  740. if (row >= rows
  741. || (data[row][col] != 0 && !pg.equals(new Point(row, col))))
  742. break;
  744. ps.add(new Point(row, col));
  745. }
  746. return ps;
  747. }
  749. /**
  750.  * 初始化数据
  751.  */
  752. private void initData() {
  753. //设置初始化游戏面板所需要的数据
  754. switch (level) {
  755. case 1:
  756. setPictureNumber(30);
  757. setTimeGiven(400);
  758. setTimeLeft(400);
  759. break;
  760. case 2:
  761. setPictureNumber(34);
  762. setTimeGiven(400);
  763. setTimeLeft(400);
  764. break;
  765. case 3:
  766. setPictureNumber(38);
  767. setTimeGiven(450);
  768. setTimeLeft(450);
  769. break;
  770. case 4:
  771. setPictureNumber(42);
  772. setTimeGiven(500);
  773. setTimeLeft(500);
  774. break;
  775. /*
  776.  * 第四，七关容易死锁所以图片数给得少
  777.  */
  778. case 5:
  779. setPictureNumber(38);
  780. setTimeGiven(500);
  781. setTimeLeft(500);
  782. case 7:
  783. setPictureNumber(38);
  784. setTimeGiven(500);
  785. setTimeLeft(500);
  786. break;
  787. default:
  788. setPictureNumber(42);
  789. setTimeGiven(500);
  790. setTimeLeft(500);
  791. break;
  792. }
  793. for (int i = 0; i < rows; i++)
  794. for (int j = 0; j < cols; j++) {
  795. data[i][j] = 0;
  796. }
  797. int numberSelected[] = null;
  798. numberSelected = selectNumbers();
  800. int m, n, selectCount = 0, figure, rowNum, columnNum;
  801. for (m = 0; m < numberSelected.length; m++) {
  802. // 从备选数字数组中顺序取出元素赋给两个由下面算法得出的数据单元
  803. figure = numberSelected[m];
  804. // n=2的目的是为了使具有相同值的数据单元成对出现
  805. for (n = 1; n <= 2; n++) {
  806. // 先选一次行号和列号
  807. rowNum = (int) (Math.random() * 10 + 1);
  808. columnNum = (int) (Math.random() * 14 + 3);
  809. /*
  810.  * 判断若先前选的行号和列号对应的数据不为空则重新选。 因为不为空则说明该位置已经被封配过了（低效 ），
  811.  * 同时保证总共选的次数不超过总单元格
  812.  */
  814. while (data[rowNum][columnNum] != 0 && selectCount < 140) {
  815. rowNum = (int) (Math.random() * 10 + 1);
  816. columnNum = (int) (Math.random() * 14 + 3);
  817. }
  818. /*
  819.  * 如果合适，那么赋值
  820.  */
  821. data[rowNum][columnNum] = figure;
  822. /*
  823.  * 成功的分配一个，计数器加一次
  824.  */
  825. selectCount++;
  826. }
  827. }
  828. // 每次初始化判断该关是否加载过，如果没有加载本关并设置图片对应关系改变了
  829. cardLeft = numberSelected.length * 2;// 初始化cardLeft
  830. pauseDuration = 0;
  831. notifyRemind();
  832. notifyLevel();
  833. notifyRecord();
  834. IsPlaying = true;
  835. }
  837. /**
  838.  * 判断是否为空
  839.  * 
  840.  * @return boolean 图片为空的话就返回true，否则就返回false
  841.  */
  842. private boolean isEmpty(Point p) {
  843. return 0 == data[p.x][p.y];
  844. }
  846. /**
  847.  * 判断给定的数字是否为偶数
  848.  * @param number
  849.  * 需要判断的数字
  850.  * @return
  851.  * boolean型的判断结果
  852.  */
  853. private boolean isEven(int number) {
  854. if (number % 2 == 0)
  855. return true;
  856. return false;
  857. }
  859. /**
  860.  * 第一关直接消
  861.  * 
  862.  * @param p1
  863.  * @param p2
  864.  */
  865. private void level1(Point p1, Point p2) {
  866. data[p1.x][p1.y] = 0;
  867. data[p2.x][p2.y] = 0;
  868. updateData();
  869. }
  871. /**
  872.  * 第十关偶数行右移，奇数行左移
  873.  * 
  874.  * @param p1
  875.  * @param p2
  876.  */
  877. private void level10(Point p1, Point p2) {
  878. /*
  879.  * 如果是偶数行那么向右移
  880.  */
  881. if (isEven(p1.x)) {
  882. for (int i = p1.y; i >= 3; i--) {
  883. data[p1.x][i] = data[p1.x][i - 1];
  884. /*
  885.  * 碰到p2则修改它的引用
  886.  */
  887. if (p1.x == p2.x && (i - 1) == p2.y) {
  888. p2 = new Point(p1.x, i);
  889. }
  890. if (data[p1.x][i - 1] == 0) {
  891. break;
  892. }
  893. }
  894. } 
  895. /*
  896.  * 如果是奇数行那么向左移
  897.  */
  898. else if (!isEven(p1.x)) {
  899. for (int i = p1.y; i <= 16; i++) {
  900. data[p1.x][i] = data[p1.x][i + 1];
  901. /*
  902.  * 碰到p2则修改它的引用
  903.  */
  904. if (p1.x == p2.x && (i + 1) == p2.y) {
  905. p2 = new Point(p1.x, i);
  906. }
  907. if (data[p1.x][i + 1] == 0) {
  908. break;
  909. }
  910. }
  911. }
  912. /*
  913.  * 如果是偶数行那么向右移
  914.  */
  915. if (isEven(p2.x)) {
  916. for (int i = p2.y; i >= 3; i--) {
  917. data[p2.x][i] = data[p2.x][i - 1];
  918. if (data[p2.x][i - 1] == 0) {
  919. break;
  920. }
  921. }
  922. } 
  923. /*
  924.  * 如果是奇数行那么向左移
  925.  */
  926. else if (!isEven(p2.x)) {
  927. for (int i = p2.y; i <= 16; i++) {
  928. data[p2.x][i] = data[p2.x][i + 1];
  929. if (data[p2.x][i + 1] == 0) {
  930. break;
  931. }
  932. }
  933. }
  934. updateData();
  935. }
  937. /**
  938.  * 第二关有垂直重力效应
  939.  */
  940. private void level2(Point p1, Point p2) {
  941. // 当遇到第一个值为0的元素或者到达边界时停止替换
  943. for (int i = p1.x; i > 0; i--) {
  944. data[i][p1.y] = data[i - 1][p1.y];
  945. // 如果碰到p2则修改p2的引用
  946. if (p1.y == p2.y && (i - 1) == p2.x) {
  947. p2 = new Point(i, p1.y);
  948. }
  949. if (data[i - 1][p1.y] == 0)
  950. break;
  951. }
  952. for (int j = p2.x; j > 0; j--) {
  953. data[j][p2.y] = data[j - 1][p2.y];
  954. if (data[j - 1][p2.y] == 0)
  955. break;
  956. }
  958. updateData();
  959. }
  961. /**
  962.  * 第三关有中间横向地裂效应
  963.  * 
  964.  * @param p1
  965.  * @param p2
  966.  */
  967. private void level3(Point p1, Point p2) {
  968. /*
  969.  * 如果在边界线上方则上升，从给定坐标元素开始 下方元素替换上方元素，并将下方元素置0，直到边界线
  970.  */
  971. if (p1.x <= 5) {
  972. for (int i = p1.x; i <= 5; i++) {
  973. if (i == 5) {
  974. data[i][p1.y] = 0;
  975. } else {
  976. data[i][p1.y] = data[i + 1][p1.y];
  977. // 碰到p2则 修改p2的引用
  978. if ((i + 1) == p2.x && p1.y == p2.y) {
  979. p2 = new Point(i, p1.y);
  980. }
  981. }
  982. }
  983. }
  984. /*
  985.  * 如果在边界线下方则下降，从给定坐标开始 上方元素替代下方元素，并将上方元素置0，直到边界线
  986.  */
  987. else if (p1.x > 5) {
  988. for (int i = p1.x; i >= 6; i--) {
  989. if (i == 6) {
  990. data[i][p1.y] = 0;
  991. } else {
  992. data[i][p1.y] = data[i - 1][p1.y];
  993. if ((i - 1) == p2.x && p1.y == p2.y) {
  994. p2 = new Point(i, p1.y);
  995. }
  996. }
  997. }
  998. }
  999. /*
  1000.  * 如果在边界线上方则上升，从给定坐标元素开始 下方元素替换上方元素，并将下方元素置0，直到边界线
  1001.  */
  1002. if (p2.x <= 5) {
  1003. for (int i = p2.x; i <= 5; i++) {
  1004. if (i == 5) {
  1005. data[i][p2.y] = 0;
  1006. } else {
  1007. data[i][p2.y] = data[i + 1][p2.y];
  1008. }
  1009. }
  1010. }
  1011. /*
  1012.  * 如果在边界线下方则下降，从给定坐标开始 上方元素替代下方元素，并将上方元素置0，直到边界线
  1013.  */
  1014. else if (p2.x > 5) {
  1015. for (int i = p2.x; i >= 6; i--) {
  1016. if (i == 6) {
  1017. data[i][p2.y] = 0;
  1018. } else {
  1019. data[i][p2.y] = data[i - 1][p2.y];
  1020. }
  1021. }
  1022. }
  1023. updateData();
  1024. }
  1026. /**
  1027.  * 第四关有向上引力
  1028.  * 
  1029.  * @param p1
  1030.  * @param p2
  1031.  */
  1032. private void level4(Point p1, Point p2) {
  1033. for (int i = p1.x; i <= 10; i++) {
  1034. data[i][p1.y] = data[i + 1][p1.y];
  1035. // 如果碰到p2则修改p2的引用
  1036. if (p1.y == p2.y && (i + 1) == p2.x) {
  1037. p2 = new Point(i, p1.y);
  1038. }
  1039. if (data[i + 1][p1.y] == 0)
  1040. break;
  1041. }
  1042. for (int j = p2.x; j <= 10; j++) {
  1043. data[j][p2.y] = data[j + 1][p2.y];
  1044. if (data[j + 1][p2.y] == 0)
  1045. break;
  1046. }
  1048. updateData();
  1049. }
  1051. /**
  1052.  * 第五关向右靠拢
  1053.  * 
  1054.  * @param p1
  1055.  * @param p2
  1056.  */
  1057. private void level5(Point p1, Point p2) {
  1059. for (int i = p1.y; i >= 3; i--) {
  1060. data[p1.x][i] = data[p1.x][i - 1];
  1061. if ((i - 1) == p2.y && p1.x == p2.x) {
  1062. p2 = new Point(p1.x, i);
  1063. }
  1064. if (data[p1.x][i - 1] == 0) {
  1065. break;
  1066. }
  1067. }
  1068. for (int j = p2.y; j >= 3; j--) {
  1069. data[p2.x][j] = data[p2.x][j - 1];
  1070. if (data[p2.x][j - 1] == 0) {
  1071. break;
  1072. }
  1073. }
  1074. updateData();
  1075. }
  1077. /**
  1078.  * 第六关纵向地裂效应
  1079.  * 
  1080.  * @param p1
  1081.  * @param p2
  1082.  */
  1083. private void level6(Point p1, Point p2) {
  1084. if (p1.y <= 9) {
  1085. for (int i = p1.y; i <= 9; i++) {
  1086. if (i == 9) {
  1087. data[p1.x][i] = 0;
  1088. } else {
  1089. data[p1.x][i] = data[p1.x][i + 1];
  1090. // 碰到p2则 修改p2的引用
  1091. if ((i + 1) == p2.y && p1.x == p2.x) {
  1092. p2 = new Point(p1.x, i);
  1093. }
  1094. }
  1095. }
  1096. }
  1097. /*
  1098.  * 如果在边界线下方则下降，从给定坐标开始 上方元素替代下方元素，并将上方元素置0，直到边界线
  1099.  */
  1100. else if (p1.y > 9) {
  1101. for (int i = p1.y; i >= 10; i--) {
  1102. if (i == 10) {
  1103. data[p1.x][i] = 0;
  1104. } else {
  1105. data[p1.x][i] = data[p1.x][i - 1];
  1106. if ((i - 1) == p2.y && p1.x == p2.x) {
  1107. p2 = new Point(p1.x, i);
  1108. }
  1109. }
  1110. }
  1111. }
  1112. /*
  1113.  * 如果在边界线上方则上升，从给定坐标元素开始 下方元素替换上方元素，并将下方元素置0，直到边界线
  1114.  */
  1115. if (p2.y <= 9) {
  1116. for (int i = p2.y; i <= 9; i++) {
  1117. if (i == 9) {
  1118. data[p2.x][i] = 0;
  1119. } else {
  1120. data[p2.x][i] = data[p2.x][i + 1];
  1121. }
  1122. }
  1123. }
  1124. /*
  1125.  * 如果在边界线下方则下降，从给定坐标开始 上方元素替代下方元素，并将上方元素置0，直到边界线
  1126.  */
  1127. else if (p2.y > 9) {
  1128. for (int i = p2.y; i >= 10; i--) {
  1129. if (i == 10) {
  1130. data[p2.x][i] = 0;
  1131. } else {
  1132. data[p2.x][i] = data[p2.x][i - 1];
  1133. }
  1134. }
  1135. }
  1136. updateData();
  1137. }
  1139. /**
  1140.  * 第七关向左靠拢
  1141.  * 
  1142.  * @param p1
  1143.  * @param p2
  1144.  */
  1145. private void level7(Point p1, Point p2) {
  1147. for (int i = p1.y; i <= 16; i++) {
  1148. data[p1.x][i] = data[p1.x][i + 1];
  1149. if ((i + 1) == p2.y && p1.x == p2.x) {
  1150. p2 = new Point(p1.x, i);
  1151. }
  1152. if (data[p1.x][i + 1] == 0) {
  1153. break;
  1154. }
  1155. }
  1156. for (int j = p2.y; j <= 16; j++) {
  1157. data[p2.x][j] = data[p2.x][j + 1];
  1158. if (data[p2.x][j + 1] == 0) {
  1159. break;
  1160. }
  1161. }
  1162. updateData();
  1163. }
  1165. /**
  1166.  * 第八关四散逃离
  1167.  * 
  1168.  * @param p1
  1169.  * @param p2
  1170.  */
  1171. private void level8(Point p1, Point p2) {
  1172. /*
  1173.  * 左上区域的向上移动
  1174.  */
  1175. if (p1.x <= 5 && p1.y <= 9) {
  1176. for (int i = p1.x; i <= 5; i++) {
  1177. if (i == 5) {
  1178. data[i][p1.y] = 0;
  1179. } else {
  1180. data[i][p1.y] = data[i + 1][p1.y];
  1181. // 如果碰到p2则修改p2的引用
  1182. if (p1.y == p2.y && (i + 1) == p2.x) {
  1183. p2 = new Point(i, p1.y);
  1184. }
  1185. }
  1186. }
  1187. }
  1188. /*
  1189.  * 右上区域的向右移动
  1190.  */
  1191. else if (p1.x <= 5 && p1.y > 9) {
  1193. for (int i = p1.y; i >= 10; i--) {
  1194. if (i == 10) {
  1195. data[p1.x][i] = 0;
  1196. } else {
  1197. data[p1.x][i] = data[p1.x][i - 1];
  1198. if ((i - 1) == p2.y && p1.x == p2.x) {
  1199. p2 = new Point(p1.x, i);
  1200. }
  1201. }
  1202. }
  1204. }
  1205. /*
  1206.  * 左下区域的向左移动
  1207.  */
  1208. else if (p1.x > 5 && p1.y <= 9) {
  1210. for (int i = p1.y; i <= 9; i++) {
  1211. if (i == 9) {
  1212. data[p1.x][i] = 0;
  1213. } else {
  1214. data[p1.x][i] = data[p1.x][i + 1];
  1215. // 碰到p2则 修改p2的引用
  1216. if ((i + 1) == p2.y && p1.x == p2.x) {
  1217. p2 = new Point(p1.x, i);
  1218. }
  1219. }
  1220. }
  1222. }
  1223. /*
  1224.  * 右下区域的向下移动
  1225.  */
  1226. else if (p1.x > 5 && p1.y > 9) {
  1228. for (int i = p1.x; i >= 6; i--) {
  1229. if (i == 6) {
  1230. data[i][p1.y] = 0;
  1231. } else {
  1232. data[i][p1.y] = data[i - 1][p1.y];
  1233. if ((i - 1) == p2.x && p1.y == p2.y) {
  1234. p2 = new Point(i, p1.y);
  1235. }
  1236. }
  1237. }
  1239. }
  1240. /*
  1241.  * 左上区域的向上移动
  1242.  */
  1243. if (p2.x <= 5 && p2.y <= 9) {
  1244. for (int i = p2.x; i <= 5; i++) {
  1245. if (i == 5) {
  1246. data[i][p2.y] = 0;
  1247. } else {
  1248. data[i][p2.y] = data[i + 1][p2.y];
  1249. }
  1250. }
  1251. }
  1252. /*
  1253.  * 右上区域的向右移动
  1254.  */
  1255. else if (p2.x <= 5 && p2.y > 9) {
  1257. for (int i = p2.y; i >= 10; i--) {
  1258. if (i == 10) {
  1259. data[p2.x][i] = 0;
  1260. } else {
  1261. data[p2.x][i] = data[p2.x][i - 1];
  1262. }
  1263. }
  1265. }
  1266. /*
  1267.  * 左下区域的向左移动
  1268.  */
  1269. else if (p2.x > 5 && p2.y <= 9) {
  1271. for (int i = p2.y; i <= 9; i++) {
  1272. if (i == 9) {
  1273. data[p2.x][i] = 0;
  1274. } else {
  1275. data[p2.x][i] = data[p2.x][i + 1];
  1276. }
  1277. }
  1279. }
  1280. /*
  1281.  * 右下区域的向下移动
  1282.  */
  1283. else if (p2.x > 5 && p2.y > 9) {
  1284. for (int i = p2.x; i >= 6; i--) {
  1285. if (i == 6) {
  1286. data[i][p2.y] = 0;
  1287. } else {
  1288. data[i][p2.y] = data[i - 1][p2.y];
  1289. }
  1290. }
  1291. }
  1292. updateData();
  1293. }
  1295. /**
  1296.  * 第九关核心引力
  1297.  * 
  1298.  * @param p1
  1299.  * @param p2
  1300.  */
  1301. private void level9(Point p1, Point p2) {
  1302. /*
  1303.  * 左上区域的向下移动
  1304.  */
  1305. if (p1.x <= 5 && p1.y <= 9) {
  1306. for (int i = p1.x; i > 0; i--) {
  1307. data[i][p1.y] = data[i - 1][p1.y];
  1308. if (p1.y == p2.y && (i - 1) == p2.x) {
  1309. p2 = new Point(i, p1.y);
  1310. }
  1311. if (data[i - 1][p1.y] == 0)
  1312. break;
  1313. }
  1314. }
  1315. /*
  1316.  * 右上区域的向左移动
  1317.  */
  1318. else if (p1.x <= 5 && p1.y > 9) {
  1319. for (int i = p1.y; i <= 16; i++) {
  1320. data[p1.x][i] = data[p1.x][i + 1];
  1321. if ((i + 1) == p2.y && p1.x == p2.x) {
  1322. p2 = new Point(p1.x, i);
  1323. }
  1324. if (data[p1.x][i + 1] == 0) {
  1325. break;
  1326. }
  1327. }
  1329. }
  1330. /*
  1331.  * 左下区域的向右移动
  1332.  */
  1333. else if (p1.x > 5 && p1.y <= 9) {
  1334. for (int i = p1.y; i >= 3; i--) {
  1335. data[p1.x][i] = data[p1.x][i - 1];
  1336. if ((i - 1) == p2.y && p1.x == p2.x) {
  1337. p2 = new Point(p1.x, i);
  1338. }
  1339. if (data[p1.x][i - 1] == 0) {
  1340. break;
  1341. }
  1342. }
  1343. }
  1344. /*
  1345.  * 右下区域的向上移动
  1346.  */
  1347. else if (p1.x > 5 && p1.y > 9) {
  1348. for (int i = p1.x; i <= 10; i++) {
  1349. data[i][p1.y] = data[i + 1][p1.y];
  1350. // 如果碰到p2则修改p2的引用
  1351. if (p1.y == p2.y && (i + 1) == p2.x) {
  1352. p2 = new Point(i, p1.y);
  1353. }
  1354. if (data[i + 1][p1.y] == 0)
  1355. break;
  1356. }
  1357. }
  1358. /*
  1359.  * 左上区域的向下移动
  1360.  */
  1361. if (p2.x <= 5 && p2.y <= 9) {
  1362. for (int j = p2.x; j > 0; j--) {
  1363. data[j][p2.y] = data[j - 1][p2.y];
  1364. if (data[j - 1][p2.y] == 0)
  1365. break;
  1366. }
  1367. }
  1368. /*
  1369.  * 右上区域的向左移动
  1370.  */
  1371. else if (p2.x <= 5 && p2.y > 9) {
  1372. for (int j = p2.y; j <= 16; j++) {
  1373. data[p2.x][j] = data[p2.x][j + 1];
  1374. if (data[p2.x][j + 1] == 0) {
  1375. break;
  1376. }
  1377. }
  1378. }
  1379. /*
  1380.  * 左下区域的向左移动
  1381.  */
  1382. else if (p2.x > 5 && p2.y <= 9) {
  1383. for (int j = p2.y; j >= 3; j--) {
  1384. data[p2.x][j] = data[p2.x][j - 1];
  1385. if (data[p2.x][j - 1] == 0) {
  1386. break;
  1387. }
  1388. }
  1389. }
  1390. /*
  1391.  * 右下区域的向下移动
  1392.  */
  1393. else if (p2.x > 5 && p2.y > 9) {
  1394. for (int j = p2.x; j <= 10; j++) {
  1395. data[j][p2.y] = data[j + 1][p2.y];
  1396. if (data[j + 1][p2.y] == 0)
  1397. break;
  1398. }
  1399. }
  1400. updateData();
  1401. }
  1403. /**
  1404.  * 加载
  1405.  */
  1406. public void load() {
  1407. notifyLoad();
  1408. }
  1410. /**
  1411.  * 加载游戏
  1412.  */
  1413. public void loadGame(){
  1414. State s=LoadAndSave.loadSave();
  1415. setCurrentScore(s.getScore());
  1416. setLastScore(s.getScore());
  1417. setLevel(s.getLevel());
  1418. setPictureFile(s.getPictureFile());
  1419. setMusic(s.getGameMusic());
  1420. setReminds(s.getReminds());
  1421. initData();
  1422. timing();// 计时
  1423. synchronized (autoTimer) {
  1424. autoTimer.notify();
  1425. startTime = System.currentTimeMillis();// 重新获取开始时间
  1426. }
  1427. paintPic();
  1428. }
  1430. /**
  1431.  * 载入游戏
  1432.  * 
  1433.  * @return 一条状态
  1434.  */
  1435. public State loadGameData() {
  1436. State s = LoadAndSave.loadSave();
  1437. return s;
  1438. }
  1440. /**
  1441.  * 载入历史记录
  1442.  */
  1443. public void loadRecord() {
  1444. records = LoadAndSave.loadRecord(TOTAL_LEVEL);
  1445. }
  1447. /**
  1448.  * 设置窗体的位置信息
  1449.  */
  1450. private void loadSet() {
  1451. frameLocation = LoadAndSave.loadLocation();
  1452. }
  1454. /**
  1455.  * 由相应的矩阵生成一个矩形对象，其左上角坐标由相应的矩阵的行号和列号以及预设的边框宽度确定 而矩形对象的长宽则匹配预设的单元长宽
  1456.  * 
  1457.  * @param row
  1458.  *            矩阵的行号，按约定从零开始
  1459.  * 
  1460.  * @param col
  1461.  *            矩阵的列号，按约定从零开始
  1462.  * 
  1463.  * @return 矩阵对对应的矩形对象
  1464.  */
  1465. public Rectangle matrixToRect(int row, int col) {
  1466. // x,y 分别表示矩形左上角的x,y 坐标。
  1467. int x = col * cellWidth + cellBorder * (col - 1);
  1468. int y = row * cellHeight + cellBorder * (row - 1);
  1469. // 通过 矩形对象的左上顶点的坐标（x，y）、宽度和高度定义这个区域并返回该 矩形 对象
  1470. return new Rectangle(x, y, cellWidth, cellHeight);
  1472. }
  1474. /**
  1475.  * 直线连
  1476.  * 
  1477.  * @param Point
  1478.  *            ,Point p1, p2前后所点的两个点
  1479.  * @return boolean 返回一个boolean值说明直线是否可连
  1480.  */
  1481. private boolean noCorner(Point p1, Point p2) {
  1482. // 只要getHSpaces(p1, p2).contains(p2)或者getVSpaces(p1,
  1483. // p2).contains(p2)中有一个为真就说明可连
  1484. return getHSpaces(p1, p2).contains(p2)
  1485. || getVSpaces(p1, p2).contains(p2);
  1486. }
  1488. /**
  1489.  * 通知帮助
  1490.  */
  1491. private void notifyAbout() {
  1492. setChanged();
  1493. notifyObservers("about");
  1494. }
  1496. /**
  1497.  * 通知通关
  1498.  */
  1499. private void notifyAccomplish() {
  1500. setChanged();
  1501. notifyObservers("accomplish");
  1502. }
  1504. private void notifyBack(){
  1505. setChanged();
  1506. notifyObservers("back");
  1507. }
  1509. /**
  1510.  * 通知破纪录
  1511.  */
  1512. private void notifyBreakRecord() {
  1513. setChanged();// 设置一个内部标志位注明数据发生了变化
  1514. notifyObservers("breakrecord");// 调用一个列表中所有的Observer的update()方法,
  1515. // 通知它们数据发生了变化
  1516. }
  1518. /**
  1519.  * 通知退出
  1520.  */
  1521. private void notifyCancel() {
  1522. setChanged();
  1523. notifyObservers("cancel");
  1524. }
  1525. /**
  1526.  * 通知系统点击了音乐按钮
  1527.  */
  1528. public void notifyClickMusic() {
  1529. setChanged();
  1530. notifyObservers("music");
  1531. }
  1532. /**
  1533.  * 通知选择了图片
  1534.  */
  1535. private void notifyClickPic() {
  1536. setChanged();
  1537. notifyObservers("pic");
  1538. }
  1539. /**
  1540.  * 通知系统点击了音乐开关
  1541.  */
  1542. private void notifyClickSound() {
  1544. setChanged();
  1545. notifyObservers("sound");
  1546. }
  1547. /**
  1548.  * 通知系统进行演示
  1549.  */
  1550. public void notifyDemo() {
  1551. setChanged();
  1552. notifyObservers("demo");
  1553. }
  1555. /**
  1556.  * 假如结束则自动调用Observer的update()方法.
  1557.  */
  1558. private void notifyDemoFinished() {
  1559. setChanged();
  1560. notifyObservers("demofinished");
  1561. }
  1563. /**
  1564.  * 通知进入游戏
  1565.  */
  1566. private void notifyEnter() {
  1567. setChanged();
  1568. notifyObservers("enter");
  1569. }
  1571. /**
  1572.  * 假如过关则自动调用Observer的update()方法，传参"level"
  1573.  */
  1574. private void notifyLevel() {
  1575. setChanged();
  1576. notifyObservers("level");
  1577. }
  1579. /**
  1580.  * 通知画线
  1581.  */
  1582. private void notifyLink() {
  1583. setChanged();
  1584. notifyObservers("link");
  1585. }
  1587. /**
  1588.  * 通知加载
  1589.  */
  1590. private void notifyLoad() {
  1591. setChanged();
  1592. notifyObservers("load");
  1593. }
  1595. /**
  1596.  * 假如无解且非演示模式则自动调用Observer的update()方法.
  1597.  */
  1598. private void notifyNoSolution() {
  1599. setChanged();
  1600. if(!IsDemo)
  1601. notifyObservers("nosolution");
  1602. }
  1604. /**
  1605.  * 游戏通关后征求玩家意见是否重新开始游戏
  1606.  */
  1607. private void notifyOption() {
  1608. setChanged();
  1609. notifyObservers("option");
  1610. }
  1612. /**
  1613.  * 通知游戏结束
  1614.  */
  1615. private void notifyOver() {
  1616. setChanged();
  1617. notifyObservers("over");
  1618. }
  1620. /**
  1621.  * 通知系统发生了暂停事件
  1622.  */
  1623. private void notifyPause() {
  1624. setChanged();
  1625. notifyObservers("pause");
  1626. }
  1628. /**
  1629.  * 通知更新历史记录
  1630.  */
  1631. private void notifyRecord() {
  1632. setChanged();
  1633. notifyObservers("record");
  1634. }
  1636. /**
  1637.  * 假如要提示则自动调用Observer的update()方法，传参"remind"
  1638.  */
  1639. private void notifyRemind() {
  1640. setChanged();
  1641. notifyObservers("remind");
  1642. }
  1644. /**
  1645.  * 通知重新开始
  1646.  */
  1647. private void notifyRestart() {
  1648. setChanged();
  1649. notifyObservers("restart");
  1650. }
  1652. /**
  1653.  * 通知退出
  1654.  */
  1655. private void notifySave() {
  1656. setChanged();
  1657. notifyObservers("save");
  1658. }
  1660. /**
  1661.  * 更新游戏界面下面的面板包括所用时间,剩余本轮可消
  1662.  */
  1663. private void notifyTimer() {
  1664. setChanged();
  1665. notifyObservers("timer");
  1666. }
  1668. /**
  1669.  * 一个弯连
  1670.  * 
  1671.  * @param Point
  1672.  *            ,Point p1, p2前后所点的两个点
  1673.  * @return boolean 返回一个boolean值说明直线是否可连
  1674.  */
  1675. private boolean oneCorner(Point p1, Point p2) {
  1676. for (Point p : getHSpaces(p1, p2)) {
  1677. // 固定行，上下遍历
  1678. if (getVSpaces(p, p2).contains(p2)) {
  1679. corner1 = p;
  1680. return true;
  1681. }
  1682. }
  1683. for (Point p : getVSpaces(p1, p2)) {
  1684. // 固定列，左右遍历
  1685. if (getHSpaces(p, p2).contains(p2)) {
  1686. corner1 = p;
  1687. return true;
  1688. }
  1689. }
  1690. return false;
  1691. }
  1693. /**
  1694.  * 判断是否超时
  1695.  * 
  1696.  * @return 超时与否
  1697.  */
  1698. private boolean overTime() {
  1699. boolean over = false;
  1700. if (getTimeLeft() == 0)
  1701. over = true;
  1702. return over;
  1703. }
  1705. /**
  1706.  * 更新图片面板
  1707.  */
  1708. public void paintPic() {
  1709. setChanged();
  1710. notifyObservers();
  1711. }
  1713. /**
  1714.  * 暂停事件
  1715.  */
  1716. public void pause() {
  1717. notifyPause();
  1718. }
  1720. public void pauseDuration() {
  1721. pauseDuration += (int) (System.currentTimeMillis() - pauseTime) / 1000;
  1722. }
  1724. /**
  1725.  * 将系统的坐标系转化为以程序定制的行列表示的point，这样做的目的是为了 让一块区域属于一张图片，那么只要你只要在这个区域里点击了，那么就认为
  1726.  * 这张图片被点击了。当然返回的坐标点还要进一步处理。
  1727.  * 
  1728.  * @param Point
  1729.  *            任何鼠标返回的系统坐标点
  1730.  * @return Point 程序定制的以行列表示的坐标点
  1731.  */
  1732. public Point pointToMatrix(Point p) {
  1733. // column 表示列号，它实际上由系统坐标轴的 x 轴确定
  1734. int col = 0;
  1735. // row 表示行号,它实际上有系统坐标轴的 y 轴确定
  1736. int row = 0;
  1737. /*
  1738.  * 这个算法的思想是:除了第一个单元，其他的的单元 不但占有宽度和高度还有一个对象间距,因此可以用除法，
  1739.  * 计算列号时x坐标除以单元宽度和间距的和，x坐标小于 这个和时，计算机结果为零，那么列行从零开始。计算 行号时与此类似
  1740.  */
  1741. col = (p.x) / (cellWidth + cellBorder);
  1742. row = (p.y) / (cellHeight + cellBorder);
  1743. return new Point(row, col);
  1744. }
  1746. /**
  1747.  * 由相应的point对象对应的生成一个矩形对象，其左上角坐标由相应的point对象的x,y坐标确定。
  1748.  * 本方法实际上是调用matrixToRect方法。
  1749.  * 
  1750.  * @param p
  1751.  *            一个point 对象，实际上该对象已经经过内部处理，实际上还是一个矩阵
  1752.  * 
  1753.  * @return Rectangle 返回指定了坐标空间中的一个区域Rectangle 对象
  1754.  */
  1755. public Rectangle pointToRect(Point p) {
  1756. return matrixToRect(p.x, p.y);
  1757. }
  1758. /**
  1759.  * 专门用于随机打乱data中数据,即打乱图片的位置,用于在无解的时候刷新 初始化数据的时候第一行到第十行以及第三列到第十六列以外的所有数据都默认为0
  1760.  */
  1762. private void randomSort() {
  1763. ArrayList<Integer> elements = new ArrayList<Integer>();
  1764. // 寻找所有不为空的元素存放在一个临时的array list里
  1765. for (int row = 1; row < rows - 1; row++) {
  1766. for (int col = 3; col < cols - 3; col++) {
  1767. if (data[row][col] != 0)
  1768. elements.add(new Integer(data[row][col]));
  1769. }
  1770. }
  1771. /*
  1772.  * 从array list里随机删除一个元素并且将该被删除元素赋给 array list 的另一个元素。
  1773.  * 这样下一次操作取随机数的时候不会产生重复，同时保证原先不为空的元素才有资格分配 一个新的元素
  1774.  */
  1775. for (int row = 1; row < rows - 1; row++) {
  1776. for (int col = 3; col < cols - 3; col++) {
  1777. if (data[row][col] != 0)
  1778. data[row][col] = elements.remove(new Random()
  1779. .nextInt(elements.size()));
  1780. ;
  1781. }
  1782. }
  1783. cellSelected = null;
  1784. /*
  1785.  * 这样随机排布后还是可能出现死锁的情况，所以必须保证最后一次 随机排列后的结果不为死锁
  1786.  */
  1787. while (solutionCount() == 0) {
  1788. randomSort();
  1789. }
  1790. }
  1791. /**
  1792.  * 随机分配现有的元素并更新界面
  1793.  */
  1794. private void refresh() {
  1795. randomSort();
  1796. paintPic();
  1797. }
  1798. /**
  1799.  * 单击提示按钮时所引发的事件
  1800.  */
  1801. public void remind() {
  1802. reminds--;
  1803. notifyRemind();
  1804. /* 如果还有提示机会则显示提示 */
  1805. if (reminds >0) {
  1806. showTip();
  1807. }
  1808. }
  1810. /**
  1811.  * 重新开始
  1812.  */
  1813. public void reStart() {
  1814. notifyRestart();
  1815. }
  1817. /**
  1818.  * 转到第一关重新开始游戏，重新初始化所有数据
  1819.  */
  1820. public void restartGame() {
  1821. setCurrentScore(0);
  1822. setLastScore(0);
  1823. setLevel(1);
  1824. setReminds(8);
  1825. initData();// 初始化数据
  1826. timing();// 计时
  1827. synchronized (autoTimer) {
  1828. autoTimer.notify();
  1829. startTime = System.currentTimeMillis();// 重新获取开始时间
  1830. }
  1831. paintPic();
  1832. }
  1834. /*
  1835.  * @see java.lang.Runnable#run() autoTimer线程每隔0.5秒检查并通知一下时间
  1836.  * 如果游戏处于进行状态并且超过时间限定，那么 通知游戏结束
  1837.  */
  1838. public void run() {
  1839. while (true) {
  1840. synchronized (autoTimer) {
  1841. try {
  1842. autoTimer.wait(500);
  1844. } catch (InterruptedException e) {
  1845. e.printStackTrace();
  1846. }
  1847. if (IsPlaying == true) {
  1848. notifyTimer();
  1849. if (overTime()) {
  1850. notifyOver();
  1851. }
  1852. }
  1853. }
  1854. }
  1855. }
  1857. /**
  1858.  * 退出游戏
  1859.  */
  1860. public void save() {
  1861. notifySave();
  1862. }
  1864. /**
  1865.  * 保存游戏的数据
  1866.  */
  1867. public void saveGame() {
  1868. String pictureFile = getPictureFile();
  1869. String musicFile = getMusic();
  1870. int level = getLevel();
  1871. int score = getLastScore();
  1872. int reminds=getReminds();
  1873. LoadAndSave.saveData(pictureFile, musicFile, level, score,reminds);
  1874. }
  1876. /**
  1877.  * 保存一条历史记录
  1878.  */
  1879. public void saveRecord() {
  1880. int playTime = getPlayTime();
  1881. int history = getRecord(level);
  1882. if (history > playTime) {
  1883. LoadAndSave.saveRecord(level, playTime);
  1884. }
  1885. }
  1887. /**
  1888.  * 保存窗体退出时候的位置信息，文件不为空的时候进行加载
  1889.  */
  1890. public void saveSet() {
  1891. if (frameLocation != null) {
  1892. LoadAndSave.saveLocation(frameLocation);
  1893. }
  1894. }
  1896. /**
  1897.  * 在所有图片中选出CARD_PARIS对图片
  1898.  * 
  1899.  * @return 图片所对应的数字集合
  1900.  */
  1901. private int[] selectNumbers() {
  1902. int[] numbers = new int[CARD_PAIRS];
  1903. int pictureNumber = getPictureNumber();
  1904. ArrayList<Integer> candidate = new ArrayList<Integer>();
  1905. for (int i = 1; i <= pictureNumber; i++) {
  1906. candidate.add(i);
  1907. }
  1908. for (int i = 0; i < CARD_PAIRS; i++) {
  1909. numbers[i] = candidate.get(new Random().nextInt(pictureNumber));
  1910. }
  1911. return numbers;
  1912. }
  1914. /**
  1915.  * 设置被选中单元
  1916.  * 
  1917.  * @param cellSelected
  1918.  *            Point 类型的被选单元
  1919.  */
  1920. public void setCellSelected(Point cellSelected) {
  1921. this.cellSelected = cellSelected;
  1922. }
  1924. /**
  1925.  * 设置当前得分
  1926.  * 
  1927.  * @param s
  1928.  *            int 类型的得分
  1929.  */
  1930. public void setCurrentScore(int score) {
  1931. currentScore = score;
  1932. }
  1934. /**
  1935.  * 设置窗体的位置，通过结束时给它传递一个位置点的参数
  1936.  * 
  1937.  * @param location
  1938.  *            点的位置
  1939.  */
  1940. public void setFrameLocation(Point location) {
  1941. frameLocation = location;
  1942. }
  1944. /**
  1945.  * 设置关过时的分数
  1946.  * 
  1947.  * @param score
  1948.  *            int 类型的得分
  1949.  */
  1950. public void setLastScore(int score) {
  1951. lastScore = score;
  1952. }
  1954. /**
  1955.  * 设置级数
  1956.  * 
  1957.  * @param i
  1958.  *            关数
  1959.  */
  1960. public void setLevel(int i) {
  1961. level = i;
  1962. }
  1964. /**
  1965.  * 设置音乐种类
  1966.  * 
  1967.  * @param pFile
  1968.  *            所选音乐种类的文件夹名字
  1969.  */
  1970. public void setMusic(String music) {
  1971. this.music = music;
  1972. }
  1974. /**
  1975.  * 设置暂停时间点
  1976.  * 
  1977.  * @param t
  1978.  *            long类型的时间点
  1979.  */
  1980. public void setPauseTime(long t) {
  1981. this.pauseTime = t;
  1982. }
  1984. /**
  1985.  * 设置图片种类
  1986.  * 
  1987.  * @param pFile
  1988.  *            所选图片种类的文件夹名字
  1989.  */
  1990. public void setPictureFile(String pFile) {
  1991. pictureFile = pFile;
  1992. }
  1994. /**
  1995.  * 设置图片数量
  1996.  * 
  1997.  * @param pn
  1998.  *            int类型的图片数量
  1999.  */
  2000. public void setPictureNumber(int pn) {
  2001. pictureNumbers = pn;
  2002. }
  2004. /**
  2005.  * 设置提示次数
  2006.  * 
  2007.  * @param reminds
  2008.  *            int 类型的提示次数
  2009.  */
  2010. public void setReminds(int reminds) {
  2012. this.reminds = reminds;
  2013. }
  2015. /**
  2016.  * 
  2017.  * @param time
  2018.  *  set timeGiven
  2019.  */
  2020. private void setTimeGiven(int time) {
  2021. timeGiven = time;
  2022. }
  2023. /**
  2024.  * 
  2025.  * @param time
  2026.  *            set timeLeft
  2027.  */
  2028. private void setTimeLeft(int time) {
  2029. timeLeft = time;
  2030. }
  2032. /**
  2033.  * 假提示
  2034.  */
  2035. public boolean showTip() {
  2036. return showTip(false);
  2037. }
  2039. /**
  2040.  * 点击提示时给玩家一条提示线
  2041.  * 
  2042.  * @param b
  2043.  *            返回一个
  2044.  * 
  2045.  * @return boolean 返回一个boolean值说明是否可连
  2046.  */
  2047. private boolean showTip(boolean b) {
  2048. // 从左到右，从上到下
  2049. for (int row1 = 0; row1 < rows; row1++)
  2050. for (int col1 = 0; col1 < cols; col1++) {
  2051. // 建立一个点p1
  2052. Point p1 = new Point(row1, col1);
  2053. // 从左到右，从上到下
  2054. for (int row2 = 0; row2 < rows; row2++)
  2055. for (int col2 = 0; col2 < cols; col2++) {
  2056. // 建立一个点p2
  2057. Point p2 = new Point(row2, col2);
  2058. // 提示
  2059. if (canDelete(p1, p2)) {
  2060. delete(p1, p2, b);
  2061. return true;
  2062. }
  2063. }
  2064. }
  2065. notifyNoSolution();// 否则无解，确定后自动刷新
  2066. refresh();
  2067. return false;
  2068. }
  2070. /**
  2071.  * 计算本轮可以消除的图片对数
  2072.  * 
  2073.  * @return 本轮可消的图片的对数
  2074.  */
  2075. public int solutionCount() {
  2076. int n = 0;
  2077. // 从左到右，从上到下
  2078. for (int row1 = 0; row1 < rows; row1++)
  2079. for (int col1 = 0; col1 < cols; col1++) {
  2080. // 建立一个点p1
  2081. Point p1 = new Point(row1, col1);
  2082. // 从左到右，从上到下
  2083. for (int row2 = 0; row2 < rows; row2++)
  2084. for (int col2 = 0; col2 < cols; col2++) {
  2085. // 建立一个点p2
  2086. Point p2 = new Point(row2, col2);
  2087. // 进行可消性判断
  2088. if (canDelete(p1, p2)) {
  2089. n++;
  2090. }
  2091. }
  2092. }
  2093. return n / 2;// 返回可消的图片的对数
  2094. }
  2096. /**
  2097.  * 开始演示模式
  2098.  */
  2099. public void startDemo() {
  2100. IsPlaying=false;
  2101. demoReminds=reminds;//记录当前提示次数
  2102. demoScore=lastScore;//记录进入这关时的得分
  2103. // 如果线程未启动那么建立一个新线程
  2104. if(demoThread==null){
  2105. demoThread = new Thread(new Runnable() {
  2106. public void run() {
  2107. while(true){
  2108. synchronized(demoThread){
  2109. if (cardLeft > 0&&IsDemo) {
  2110. if (!showTip(false)) {
  2112. }
  2113. try {// 延迟0.5秒
  2114. demoThread.wait(500);
  2115. } catch (InterruptedException e) {
  2116. e.printStackTrace();
  2117. }
  2118. showTip(true);
  2119. try {
  2120. demoThread.wait(500);
  2121. } catch (InterruptedException e) {
  2122. e.printStackTrace();
  2123. }
  2124. paintPic();// 重绘图片面板
  2125. }
  2126. else {
  2127. reminds =demoReminds ;// 演示完成后恢复初始提示机会
  2128. currentScore=demoScore;//演示完成后恢复初始得分
  2129. //如果图片消完了，那么通知演示结束
  2130. if(IsDemo && cardLeft==0){
  2131. notifyDemoFinished();
  2132. }
  2133. //如果中途退出了那么从本关重新开始游戏
  2134. else if(!IsDemo){
  2135. startGame(false);
  2136. }
  2137. //演示线程进入无限等待，直到被唤醒
  2138. try {
  2139. demoThread.wait();
  2140. } catch (InterruptedException e) {
  2141. e.printStackTrace();
  2142. }
  2143. }
  2144. }
  2145. }
  2146. }
  2147. });
  2148. demoThread.start();
  2149. }
  2150. //唤醒演示线程并且进入演示模式
  2151. synchronized(demoThread){
  2152. demoThread.notify();
  2153. IsDemo=true;
  2154. }
  2155. }
  2157. /**
  2158.  * 开始游戏，如果是转到下一关则增加提示机会，如果是转到当前关则不增加
  2159.  * @param nextLevel 
  2160.  * 是否转到下一关
  2161.  */
  2162. public void startGame(boolean nextLevel) {
  2163. if(nextLevel){
  2164. //增加两次提是机会，最多加到8次为止
  2165. if (reminds <=TOTAL_REMIND-2)
  2166. setReminds(reminds + 2);
  2167. else {
  2168. setReminds(TOTAL_REMIND);
  2169. }
  2170. }
  2171. initData();// 初始化数据
  2172. timing();
  2173. synchronized (autoTimer) {
  2174. autoTimer.notify();
  2175. startTime = System.currentTimeMillis();// 得到开始时间
  2176. }
  2177. paintPic();
  2178. }
  2180. /**
  2181.  * 停止演示模式
  2182.  */
  2183. public void stopDemo() {
  2184. IsDemo = false;
  2185. }
  2187. /**
  2188.  * 计时器
  2189.  */
  2190. private void timing() {
  2191. if (autoTimer == null) {
  2192. autoTimer = new Thread(this);
  2193. autoTimer.start();
  2194. }
  2195. }
  2197. /**
  2198.  * 两个弯连
  2199.  * 
  2200.  * @param Point
  2201.  *            ,Point p1, p2前后所点的两个点
  2202.  * @return boolean 返回一个boolean值说明直线是否可连
  2203.  */
  2204. private boolean twoCorner(Point p1, Point p2) {
  2205. for (Point ph : getHSpaces(p1, p2)) {
  2206. // 固定行，上下遍历
  2207. for (Point pv : getVSpaces(ph, p2)) {
  2208. // 再固定列，左右遍历
  2209. if (getHSpaces(pv, p2).contains(p2)) {
  2210. corner1 = ph;
  2211. corner2 = pv;
  2212. return true;
  2213. }
  2214. }
  2215. }
  2216. for (Point pv : getVSpaces(p1, p2)) {
  2217. // 固定列，左右遍历
  2218. for (Point ph : getHSpaces(pv, p2)) {
  2219. // 再固定行，上下遍历
  2220. if (getVSpaces(ph, p2).contains(p2)) {
  2221. corner1 = ph;
  2222. corner2 = pv;
  2223. return true;
  2224. }
  2225. }
  2226. }
  2227. return false;
  2228. }
  2230. /**
  2231.  * 更新数据，用于每次过关
  2232.  */
  2233. private void updateData() {
  2234. cardLeft -= 2;
  2235. timeLeft += 1;
  2236. currentScore += 5;
  2237. linkSound.play(false);
  2238. paintPic();
  2239. }
  2241. private boolean withinBound(Point p) {
  2242. return ((p.x >= 0) && (p.x < rows) && (p.y >= 0) && (p.y < cols));
  2243. }
  2244. }