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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
MineSquare.java
资源名称：扫雷(java).rar　[点击查看]
上传用户：penghbff
上传日期：2007-04-16
资源大小：32k
文件大小：9k
源码类别：

射击游戏

开发平台：

Java

MineSquare.java：源码内容
  1. import java.awt.event.*;
  2. import java.awt.*;
  3. import javax.swing.*;
  4. import java.util.*;
  5. import java.io.*;
  6. public class MineSquare extends JPanel implements MouseListener
  7. { 
  8.   int rows=10,cols=10,雷数=10;
  9.   JButton buttonFace=null;
  10.   Block block[][];             
  11.   TimeCount time;              
  12.   CountMine count;            
  13.   String grade=null;          
  14.   RandomSetMine 随机布雷者;
  15.   FindAroundMineNumber 确定周围雷数者;
  16.   FindSafeArea  找出无雷连通区者;
  17.   DetermineDigArea 成片挖开者;
  18.   DetermineMineMarkIsRightOrWrong 确定雷标记是否正确者;
  19.   FindAroundMineMarkNumber 确定周围雷标数目者;
  20.   DecideWinner 判断是否胜利者; 
  21.   Record 记录对话框=null;
  22.   public MineSquare(String grade,int mineNumber,int rows, int cols,JButton b,JDialog dialog)
  23.    { 
  24.      this.grade=grade;
  25.      this.rows=rows;
  26.      this.cols=cols;
  27.      雷数=mineNumber;
  28.      判断是否胜利者=new DecideWinner();
  29.      记录对话框=(Record)dialog;
  30.      block=new Block[rows+1][cols+1];
  31.      buttonFace=b;
  32.      time=new TimeCount();
  33.      count=new CountMine(雷数);
  34.      count.textShowMine.setText(""+雷数);
  35.      setLayout(new GridLayout(rows,cols));
  36.      for(int i=1;i<=rows;i++)
  37.        {for(int j=1;j<=cols;j++)
  38.          { 
  39.            block[i][j]=new Block();
  40.            block[i][j].设置在雷区中的位置(i,j);
  41.          }
  42.        }
  43.      for(int i=1;i<=rows;i++)
  44.        {for(int j=1;j<=cols;j++)
  45.          { 
  46.            add(block[i][j].label);
  47.            block[i][j].addMouseListener(this);
  48.          }
  49.        }
  50.      随机布雷者=new RandomSetMine();
  51.      随机布雷者.随机布雷(雷数,block,rows,cols);
  52.      确定周围雷数者=new FindAroundMineNumber();
  53.      for(int i=1;i<=rows;i++)
  54.        {for(int j=1;j<=cols;j++)
  55.           {        
  56.            确定周围雷数者.设置周围的雷数(i,j,block,rows,cols);
  57.           }
  58.        }
  59.    }
  60.  public void gameOver()
  61.   {
  62.       time.interrupt();
  63.       buttonFace.setIcon(new ImageIcon("哭脸.gif"));
  64.       for(int i=1;i<=rows;i++)
  65.        { for(int j=1;j<=cols;j++)
  66.           {
  67.             block[i][j].removeMouseListener(this);
  68.             if(block[i][j].判断是否是雷()&&block[i][j].isOpaque()&&block[i][j].探雷标记!=0)
  69.                { 
  70.                   block[i][j].requestFocus();
  71.                   block[i][j].setOpaque(false);  
  72.                }
  73.             if(block[i][j].探雷标记==0&&!block[i][j].判断是否是雷())
  74.                { 
  75.                  block[i][j].requestFocus();
  76.                  block[i][j].探雷标记=-1;   
  77.                  block[i][j].repaint();
  78.                  block[i][j].setIcon(new ImageIcon("探雷错误.gif")); 
  79.                }
  80.           }
  81.        }
  82.   } 
  83.  public void mousePressed(MouseEvent e)
  84.   { 
  85.     boolean left=SwingUtilities.isLeftMouseButton(e);
  86.     boolean right=SwingUtilities.isRightMouseButton(e);
  87.     Block blockSource=(Block)e.getSource();
  88.     boolean 雷=blockSource.判断是否是雷();
  89.    if(left==true&&blockSource.isOpaque()==true&&blockSource.获取探雷标记()!=0)
  90.    {   
  91.        try{time.start();  
  92.        }                  
  93.        catch(Exception ee){   
  94.        }
  95.        if(雷==true)
  96.           {  
  97.            blockSource.requestFocus();
  98.            blockSource.setOpaque(false);   
  99.            blockSource.探雷标记=-1;
  100.            blockSource.repaint();
  101.            blockSource.setIcon(new ImageIcon("触雷.gif"));
  102.            gameOver();                    
  103.           }
  104.        else
  105.           {  
  106.             buttonFace.setIcon(new ImageIcon("微笑脸.gif"));
  107.             if(blockSource.周围无雷==false&&blockSource.获取探雷标记()!=0)  
  108.               {
  109.                blockSource.setOpaque(false);  
  110.                blockSource.探雷标记=-1;
  111.                blockSource.repaint();
  112.               }
  113.            
  114.             if(blockSource.周围无雷==true&&blockSource.isOpaque())
  115.               { 
  116.                blockSource.setOpaque(false);     
  117.                Point blockPoint=(Point)blockSource.获取在雷区中的位置();
  118.                int i=blockPoint.x;
  119.                int j=blockPoint.y;
  120.                找出无雷连通区者=new FindSafeArea();
  121.                Vector tree=找出无雷连通区者.确定无雷连通区(i,j,block,rows,cols);
  122.                for(int index=0;index<tree.size();index++)
  123.                  {  
  124.                   Point p=(Point)tree.elementAt(index);
  125.                   int m=p.x,n=p.y;
  126.                   for(int k=Math.max(m-1,1);k<=Math.min(m+1,rows);k++)
  127.                     { 
  128.                       for(int t=Math.max(n-1,1);t<=Math.min(n+1,cols);t++)
  129.                       {
  130.                         if(block[k][t].探雷标记==0)
  131.                             {  
  132.                                gameOver();
  133.                             }
  134.                         else{  
  135.                              block[k][t].requestFocus();
  136.                              block[k][t].setOpaque(false);  
  137.                              block[k][t].探雷标记=-1;
  138.                              block[k][t].repaint();
  139.                             }
  140.                       } 
  141.                     }
  142.                  }
  143.                tree.removeAllElements();                   
  144.               }
  145.           }
  146.     }
  147.    if(right)
  148.     { 
  149.       if(blockSource.探雷标记==0&&blockSource.isOpaque())
  150.          {                                             
  151.            count.countMineSub();                      
  152.          }
  153.       if(blockSource.探雷标记==1&&blockSource.isOpaque())
  154.          {                                           
  155.            count.countMineAdd();                    
  156.          }
  157.     }
  158.  }
  159.  public void mouseEntered(MouseEvent e)
  160.   {}
  161.  public void mouseReleased(MouseEvent e)
  162.   { 
  163.     boolean success=判断是否胜利者.判断是否成功(雷数,block,rows,cols);
  164.     if(success==true)
  165.     { 
  166.            time.interrupt();                        
  167.            记录对话框.setGrade(grade);             
  168.            int spendTime=Integer.parseInt(time.textShowTime.getText());  
  169.            记录对话框.setTime(spendTime);
  170.           
  171.            File f=new File("英雄榜.txt");
  172.            try{
  173.                 FileInputStream in=new FileInputStream(f);
  174.                 ObjectInputStream object_in=new ObjectInputStream(in);
  175.                 Hashtable hashtable=(Hashtable)object_in.readObject();  
  176.                 object_in.close();
  177.                 in.close(); 
  178.                 String temp=(String)hashtable.get(grade);            
  179.                 StringTokenizer fenxi=new StringTokenizer(temp,"#"); 
  180.                 fenxi.nextToken();
  181.                 int recordTime=Integer.parseInt(fenxi.nextToken());  
  182.                  if(spendTime<recordTime)                           
  183.                    记录对话框.setVisible(true);                     
  184.                }
  185.             catch(Exception eee)
  186.                {
  187.                }
  188.     } 
  189.   }
  190.  public void mouseExited(MouseEvent e)
  191.   {}
  192.  public void mouseClicked(MouseEvent e)
  193.   {  
  194.     if(SwingUtilities.isRightMouseButton(e)) 
  195.     { Block blockSource=(Block)e.getSource();
  196.       Point blockPoint=(Point)blockSource.获取在雷区中的位置();
  197.                int i=blockPoint.x;
  198.                int j=blockPoint.y;
  199.       确定周围雷标数目者=new FindAroundMineMarkNumber();
  200.       int 周围雷标数=确定周围雷标数目者.获取周围雷标记的数目(i,j,block,rows,cols);
  201.       int 周围雷数=blockSource.获取周围的雷数();
  202.       确定雷标记是否正确者=new DetermineMineMarkIsRightOrWrong();
  203.       boolean correct=确定雷标记是否正确者.判断雷标记是否正确(i,j,block,rows,cols);
  204.       if(blockSource.isOpaque()==false&&周围雷数>0&&correct)
  205.        {  
  206.           成片挖开者=new DetermineDigArea();
  207.           Vector tree=成片挖开者.确定成片挖开区域(i,j,block,rows,cols);
  208.           for(int index=0;index<tree.size();index++)
  209.              {
  210.                 Point p=(Point)tree.elementAt(index);
  211.                 int m=p.x,n=p.y;
  212.                 for(int k=Math.max(m-1,1);k<=Math.min(m+1,rows);k++)
  213.                    {
  214.                     
  215.                      for(int t=Math.max(n-1,1);t<=Math.min(n+1,cols);t++)
  216.                       { 
  217.                          if(block[k][t].isOpaque()&&!block[k][t].判断是否是雷()&&
  218.                             block[k][t].探雷标记!=0)
  219.                           {
  220.                             block[k][t].requestFocus();
  221.                             block[k][t].setOpaque(false);  
  222.                             block[k][t].探雷标记=-1;
  223.                             block[k][t].repaint();
  224.                           }
  225.                         repaint();
  226.                       } 
  227.                     }
  228.               }
  229.            tree.removeAllElements();
  230.        } 
  231.        if(blockSource.isOpaque()==false&&周围雷标数==周围雷数&&!correct)
  232.        { 
  233.          gameOver();                  
  234.        }
  235.       if((blockSource.isOpaque())==false&&(周围雷标数!=周围雷数))
  236.        {
  237.        }
  238.    }
  239.   }
  240. }