项目二黄金矿工 2

最新推荐文章于 2022-11-19 19:35:02 发布

春风十里扬州路�

最新推荐文章于 2022-11-19 19:35:02 发布

阅读量602

点赞数 2

文章标签： java 游戏

本文链接：https://blog.csdn.net/wwh0989/article/details/119386161

版权

黄金矿工 2

13 拉取速度
14 多种金块和物体堆叠情况
15 红线完善
16 积分设置
17 力量与爆破
18 设置关卡
19 游戏状态
计时效果
失败、成功状态
总结

13 拉取速度

先在 Object类 中添加变量m 记录属性，分别让石块和金块赋值

Gold(){
    this.m = 80;
}
Rock(){  
    this.m = 150;
}

绳子共有三种状态 0：摇摆 1：抓取 2：收回 3:抓取返回
只有状态三时，拉到石块和金块的返回速度不一样

只修改Line类中 case3部分代码

case 3:
     int m=1;
     if (length>100){
          length=length-10;
          lines(g);
//减去偏移量  金块长度的一半
          for (Object obj: frame.objectList){
              if (obj.flag==true){
//抓到物体之后，将物体的质量付给m
                   m=obj.m;
                   obj.x=endx-obj.getWidth()/2;
                   obj.y=endy;
                       if (length<=100){
               //抓取成功，直接将金块移除  -150就是放在屏幕外面
                          obj.x= -150;
                          obj.y= -150;
                          obj.flag=false;
                          state = 0;
                            }
                        }
                    }
                }

在后面添加延时代码，时间就是质量，质量越大，延时效果越长

try {
      Thread.sleep(m);
} catch (InterruptedException e) {
      e.printStackTrace();
}

14 多种金块和物体堆叠情况

在 Gold类 中，加入两个类GoldMini ,GoldPlus, 分别表示大金块小金块

class GoldMini extends Gold{
    GoldMini(){
        this.width = 36;
        this.height = 36;
        this.m = 15;
        this.img = Toolkit.getDefaultToolkit().getImage("imgs/gold0.gif");
    }
}

class GoldPlus extends Gold{
    GoldPlus(){
        this.x=(int) (Math.random()*650);
        this.width = 105;
        this.height = 105;
        this.m = 60;
        this.img = Toolkit.getDefaultToolkit().getImage("imgs/gold2.gig");
    }

在GimeWin中的创建金块石块的方法体中

//创建金块，石块
    {
//        定义变量，表示是否可以放置
        boolean isPlace = true;
        for (int i=0;i<11;i++){
//            生成随机数，为后面大金块小金块的出现概率做准备,当生成的随机数小于0.3，生成小金块
//            添加石块、金块时，需要判断是否和已存在物体堆叠，需要先进行判断
            double random = Math.random();
            Gold gold;   //存放当前生成金块
            if (random<0.3){
                objectList.add(gold=new GoldMini());
            }else if (random<0.7){
                objectList.add(gold=new Gold());
            }else {
                objectList.add(gold=new GoldPlus());
            }
            for (Object object:objectList){
                if (gold.getRec().intersects(object.getRec())){
//                    不可重复放置，需要重新生成
                    isPlace=false;
                    i--;
                }
                if (isPlace){
                    objectList.add(gold);
                }else {
                    isPlace=true;
                    i--;
                }
            }
        }
        
//生成石块
        for (int i=0;i<5;i++){
            Rock rock = new Rock();
           for (Object obj:objectList){
//               如果说出现重合现象，不可放置
               if (rock.getRec().intersects(obj.getRec())){
                   isPlace = false;
               }
           }
//           如果可以放置
           if (isPlace){
               objectList.add(rock);
           }else {
               isPlace=true;
               i--;
           }
        }
    }

15 红线完善

Line类中
在红线末端加入钩子
在绘制红线方法中，对红线加粗并且把钩子放上去

//    添加钩爪图片
Image hook = Toolkit.getDefaultToolkit().getImage("imgs/hook.png");


void lines(Graphics g){
        endx = (int) (x + length*Math.cos(n*Math.PI));
        endy = (int) (y+ length*Math.sin(n*Math.PI));
        g.setColor(Color.RED);
//        红线实现加粗功能
        g.drawLine(x,y,endx,endy);
        g.drawLine(x-1,y,endx-1,endy);
        g.drawLine(x+1,y,endx+1,endy);
//        钩爪在红线的下面，红线放置在钩爪中心位置
        g.drawImage(hook,endx-36,endy+2,null);
    }

16 积分设置

在Object类中定义积分，金块：小金块2，大金块8，普通金块4 ，石块1
Object类

//    添加积分
int count;

金块类石块类中重写

Gold(){
	this.count = 4;
}
GoldMini(){
	this.count = 2;
}
GoldPlus(){
	this.count = 2;
}
Rock(){
	this.count = 1;
}

Line类中，在case3（抓取成功）情况下判定，每次加多少积分

if (obj.flag==true){
//抓到物体之后，将物体的质量付给m
   m=obj.m;
   obj.x=endx-obj.getWidth()/2;
   obj.y=endy;
   if (length<=MIN_length){
//抓取成功，直接将金块移除  -150就是放在屏幕外面
       obj.x= -150;
       obj.y= -150;
       obj.flag=false;
//计算总分,等于当前分数加上被抓物体的分数
       Bg.count = obj.count;
       state = 0;
    }
}

在背景类( Gg.java )中写入积分，创建文字框方法，在绘制背景中调用

public class Bg {
//        总分
    static int count = 0;
  
//    绘制背景
    void paintSelf(Graphics g){
    drawWord(g,30,Color.black,"积分："+count,30,150);
}
//    绘制字符串
	public static void drawWord(Graphics graphics, int size,Color color,String str,int x,int y){
        graphics.setColor(color.BLACK);
//        宋体加粗大小30
        graphics.setFont(new Font("微软雅黑",Font.BOLD,size));
//        打印字符串，当前积分，在（30，150）坐标位置上
        graphics.drawString(str+count,x,y);
    }
}

17 力量与爆破

添加爆破，抓到石块，鼠标点右键石块消失
添加力量，抓金块时右键快速拉回
所以我们添加药水功能，在抓到石块或金块后完成相应功能

现在 Bg.java 中添加药水总量，药水状态以及绘制药水

//    定义存放药水数量的参数
    static  int waterNum = 3;
//    药水状态,true表示正在使用
    static boolean waterFlag = false;

//    添加药水图片
    Image water  = Toolkit.getDefaultToolkit().getImage("imgs/water.png");

//    绘制背景
void paintSelf(Graphics g){
    drawWord(g,30,Color.black,"*"+waterNum,550,70);
}

在 GameWin.java类 上添加鼠标单击事件

void launch(){
addMouseListener(new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) {
         super.mouseClicked(e);
// 点击鼠标左键（e.getButton()==1），线当前状态为0（摇摆）,点击后线的状态为抓取
         if (e.getButton()==1&&line.state==0){
             line.state=1;
         }else if (e.getButton()==3 && line.state==3){
// 在线抓取并且 点击鼠标右键（e.getButton()==3）后，药水状态为正在使用，药水减1
              Bg.waterFlag=true;
              Bg.waterNum--;
              line.state=2;
          }
     }
  });
}

在Line.java的case3 判断中

     case 3:
                int m=1;
                if (length>MIN_length){
                    length=length-10;
                    lines(g);
//                    减去偏移量  金块长度的一半
                    for (Object obj: frame.objectList){
                        if (obj.flag==true){
//                            抓到物体之后，将物体的质量付给m
                            m=obj.m;
                            obj.x=endx-obj.getWidth()/2;
                            obj.y=endy;
                            if (length<=MIN_length){
                                //抓取成功，直接将金块移除  -150就是放在屏幕外面
                                obj.x= -150;
                                obj.y= -150;
                                obj.flag=false;
//                                计算总分,等于当前分数加上被抓物体的分数
                                Bg.count = obj.count;
                                state = 0;
                            }
//*************************************************************************************
                            if (Bg.waterFlag){
                                if (obj.type==1){
                                    m=1;
                                    //将刷新频率变小，视觉上就显示拉的快了
                                }
                                if (obj.type==2){
                                    obj.x= -150;
                                    obj.y= -150;
                                    obj.flag=false;
                                    //拉到石块直接移除
                                }
                            }
//*************************************************************************************
                        }
                    }
                }
//                把m作为刷新频率
                try {
                    Thread.sleep(m);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                break;

如果waterFlag变为真，表示药水使用，但是还要判断是否抓到金块或者石块，金块快速拉回，石块爆破

所以在Object类中添加变量,让石块金块重写

//类型1 石块  类型2  石块
int type;

Gold(){
	this.type=1;
}
Rock(){
	this.type=2;
}

18 设置关卡

在背景类 Bg.java 中添加关卡、关卡分数，在绘制方法中将其绘制出来

//    定义关卡
    static int level = 1;
//    定义每一关的目标得分
    int goal = level*5;

//    绘制背景
void paintSelf(Graphics g){
        g.drawImage(bg,0,200,null);
        g.drawImage(bg1,0,0,null);
        g.drawImage(peo,310,50,null);
        g.drawImage(water,490,40,null);=
        drawWord(g,30,Color.black,"积分："+count,30,150);
        drawWord(g,30,Color.black,"*"+waterNum,550,70);
//        绘制关卡数和目标积分
        drawWord(g,20,Color.black,"第"+level+"关",30,60);
        drawWord(g,30,Color.black,"目标"+goal,30,110);
}

在主类中 GameWin.java 创建函数，并且在绘制窗口方法中，有一个循环，循环中调用下一关函数

//    窗口绘制方法
    void launch(){
        while (true){
            repaint();
            nextLevel();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

//    进入下一关
    public void nextLevel(){
    //如果此时积分大于目标积分
        if (Bg.count>bg.goal){
            System.out.println("过关");
            //关闭之前窗口
            dispose();
            //关卡加1
            Bg.level++;
            //绘制新窗口
            GameWin gameWin = new GameWin();
            gameWin.launch();
        }
    }

19 游戏状态

游戏状态有5种，
0:准备 1：运行中 2：商店 3：失败 4：胜利
在 GameWin.java 中添加静态变量记录状态

//    表示整个游戏的状态  0:准备   1：运行中  2：商店  3：失败  4：胜利
    static int state;

void launch(){     
        addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                super.mouseClicked(e);

                switch (state){
                    case 0:
//                        点击右键，游戏开始
                        if (e.getButton()==3){state=1;}
                        break;
                    case 1:
//                点击鼠标左键（e.getButton()==1），线当前状态为0（摇摆）,点击后线的状态为抓取
                        if (e.getButton()==1&&line.state==0){
                            line.state=1;
                        }else if (e.getButton()==3 && line.state==3){
//               在线抓取并且 点击鼠标右键（e.getButton()==3）后，药水状态为正在使用，药水减1
                            Bg.waterFlag=true;
                            Bg.waterNum--;
                            line.state=2;
                        }
                        break;
                    case 2:
                        break;
                    case 3:
                        break;
                    case 4:
                        break;
                    default:
                }
            }
        });

在鼠标事件中，添加游戏状态

同时，在Bg.java中对绘制背景也进行判断

//    绘制背景
    void paintSelf(Graphics g){

        g.drawImage(bg,0,200,null);
        g.drawImage(bg1,0,0,null);

        switch (GameWin.state){
            case 0:
                drawWord(g,80,Color.blue,"准备开始",200,400);
                break;
            case 1:
//                游戏运行状态才化人物等
                g.drawImage(peo,310,50,null);
                g.drawImage(water,490,40,null);

                drawWord(g,30,Color.black,"积分："+count,30,150);
                drawWord(g,30,Color.black,"*"+waterNum,550,70);

//        绘制关卡数和目标积分
                drawWord(g,20,Color.black,"第"+level+"关",30,60);
                drawWord(g,30,Color.black,"目标"+goal,30,110);
                break;
            case 2: break;
            case 3: break;
            case 4: break;
            default:
        }

计时效果

在 Bg.java 中添加起始时间和结束时间

public class Bg {
//    开始时间
    long startTime;
//    结束时间
    long endTime;
    
//    绘制背景
    void paintSelf(Graphics g){

        g.drawImage(bg,0,200,null);
        g.drawImage(bg1,0,0,null);

        switch (GameWin.state){
            case 0:
                drawWord(g,80,Color.blue,"准备开始",200,400);

                break;
            case 1:
//                游戏运行状态才化人物等
                g.drawImage(peo,310,50,null);
                g.drawImage(water,490,40,null);

                drawWord(g,30,Color.black,"积分："+count,30,150);
                drawWord(g,30,Color.black,"*"+waterNum,550,70);

//        绘制关卡数和目标积分
                drawWord(g,20,Color.black,"第"+level+"关",30,60);
                drawWord(g,30,Color.black,"目标"+goal,30,110);
//*************************************************************************************
//                状态为1 实时赋值
                endTime=System.currentTimeMillis();
//                /1000 将毫秒换算成秒   20-(endTime-startTime)/1000   从20开始倒计时
                long time = 20-(endTime-startTime)/1000;
                drawWord(g,30,Color.black,"时间"+(time>0?time:0),520,110);
//*************************************************************************************
                break;
            case 2: break;
            case 3: break;
            case 4: break;
            default:
}

失败、成功状态

在 Bg.java 中paintSelf方法的case判断中进行添加
0:准备 1：运行中 2：商店 3：失败 4：胜利
这里我们先在 GameWin.java 的 nextLevel方法中加判断：

//    进入下一关  游戏倒计时结束，并且处于运行中，进入状态1，否则进行状态失败
    public void nextLevel(){
//        游戏开始阶段才能判断下一关
        if (bg.gameTime() && state==1){
//           如果本次取得的分数大于规定分数
            if (Bg.count>bg.goal){
//                如果打到最后一关，
                if (Bg.level==5){
                    state=4;
                }else {
                    Bg.level++;
                }
                System.out.println("过关");
                dispose();
                Bg.level++;
                GameWin gameWin = new GameWin();
                gameWin.launch();
            }
        }else {
            state=3;
        }
    }

这里写state3 在 Bg.java 中paintSelf方法的case判断中写，打印两句话就行

//失败
case 3:
     drawWord(g,80,Color.black,"失败",250,350);
     drawWord(g,80,Color.black,"积分"+count,200,450);
     break;
//打通五关，胜利
            case 4:
                drawWord(g,80,Color.black,"成功",250,350);
                drawWord(g,80,Color.black,"积分"+count,200,450);
                break;
            default:
        }

总结

Game.java

变量：状态、列表（放金块石块，所以用Object接收）、背景类对象、绳子类对象、创建第二个背景（解决闪动问题）

public class GameWin extends JFrame {

//    表示整个游戏的状态  0:准备   1：运行中  2：商店  3：失败  4：胜利
    static int state;
//    可以用来放金块，石块
    List<Object> objectList = new ArrayList<>();
    
    Bg bg = new Bg();
    Line line = new Line(this);

    Image offScreenImage;
}

创建方法体 {} ，来写石块金块，变量 isPlace 的作用是为了判断是否冲突（不能重复放置）

//创建金块，石块
    {
//        定义变量，表示是否可以放置
        boolean isPlace = true;

//        放置金块
        for (int i=0;i<11;i++){
//            生成随机数，为后面大金块小金块的出现概率做准备,当生成的随机数小于0.3，生成小金块
//            添加石块、金块时，需要判断是否和已存在物体堆叠，需要先进行判断
            double random = Math.random();
            Gold gold;   //存放当前生成金块
            if (random<0.3){
                gold=new GoldMini();
            }else if (random<0.7){
                gold=new Gold();
            }else {
                gold=new GoldPlus();
            }
            for (Object obj:objectList){
                if (gold.getRec().intersects(obj.getRec())){
//                    gold的位置与现有的物体位置重合，则不可重复放置，需要重新生成
                    isPlace=false;
                    i--;
                }
            }

            if (isPlace){
                objectList.add(gold);
            }else {
                isPlace=true;
                i--;
            }
        }

        //        放置石块
        for (int i=0;i<5;i++){
            Rock rock = new Rock();
           for (Object obj:objectList){
//               如果说出现重合现象，不可放置
               if (rock.getRec().intersects(obj.getRec())){
                   isPlace = false;
               }
           }
//           如果可以放置
           if (isPlace){
               objectList.add(rock);
           }else {
               isPlace=true;
               i--;
           }
        }
    }

画窗体
绘制窗体需要添加鼠标单击事件，这里就用到变量状态— 0：准备 1：运行中 2：商店 3：失败 4：胜利

//    窗口绘制方法
    void launch(){
        this.setVisible(true);
        this.setSize(768,1000);
//        设置窗口位置，居中
        this.setLocationRelativeTo(null);
        this.setTitle("黄金矿工");
//        关闭窗口
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                super.mouseClicked(e);

                switch (state){

                    case 0:
//                        点击右键，游戏开始，给出初始时间
                        if (e.getButton()==3){
                            state=1;
//                            状态为1   游戏开始时间为系统时间
                            bg.startTime=System.currentTimeMillis();
                        }
                        break;

                    case 1:
//              点击鼠标左键（e.getButton()==1），线当前状态为0（摇摆）,点击后线的状态为抓取
                        if (e.getButton()==1&&line.state==0){
                            line.state=1;
                        }else if (e.getButton()==3 && line.state==3){
//              在线抓取并且 点击鼠标右键（e.getButton()==3）后，药水状态为正在使用，药水减1
                            Bg.waterFlag=true;
                            Bg.waterNum--;
                            line.state=2;
                        }
                        break;

                    case 2:
                        break;

                    case 3:
                        break;

                    case 4:
//                        胜利后重置游戏
                        if (e.getButton()==1){
                            state=0;
                            //reGame是重启游戏的方法，后面会写
                            bg.reGame();
                            line.reGame();
                        }
                        break;

                    default:
                }
            }
        });

        while (true){
            repaint();
            nextLevel();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

case1中涉及到绳子的状态，后续在Line.java中会写

paint方法
就是画图片

//    绘制图片
//    Graphics 代表画笔
    public void paint(Graphics g){
//创建一个一摸一样的画布，放在最下层，每次重新绘制时，就不会出现闪动现象
//        创建两个画布，一个放在最下面，第一步先把金块背景放进去
        offScreenImage = this.createImage(768,1000);
        Graphics gImage = offScreenImage.getGraphics();
        bg.paintSelf(gImage);

        if (state==1){
            //绘制金块，采用增强for循环
            for (Object obj:objectList){
                obj.paintSelf(gImage);
            }

            line.paintSelf(gImage);
        }

//        第二步把画布画到背景中
        g.drawImage(offScreenImage,0,0,null);
    }

nextLevel
进入下一关游戏倒计时结束，并且处于运行中，进入状态1，否则进行状态失败

public void nextLevel(){
//        游戏开始阶段才能判断下一关
        if (bg.gameTime() && state==1){
//           如果本次取得的分数大于规定分数
            if (Bg.count>bg.goal){
//                如果打到最后一关，
                if (Bg.level==5){
                    state=4;
                }else {
                    Bg.level++;
                }
                System.out.println("过关");
                dispose();
                Bg.level++;
                GameWin gameWin = new GameWin();
                gameWin.launch();
            }
        }else {
            state=3;
        }
    }

Bg.java

定义变量 背景需要积分，药水，关卡，开始时间，结束时间，需要添加背景图片（人物，背景），药水图片

//        总分
    static int count = 0;
//    定义存放药水数量的参数
    static  int waterNum = 3;
//    药水状态,true表示正在使用
    static boolean waterFlag = false;
//    定义关卡
    static int level = 1;
//    定义每一关的目标得分
    int goal = level*5;

//    开始时间
    long startTime;
//    结束时间
    long endTime;
    
	Image bg = Toolkit.getDefaultToolkit().getImage("imgs/bg.jpg");
    Image bg1 = Toolkit.getDefaultToolkit().getImage("imgs/bg1.jpg");
    Image peo = Toolkit.getDefaultToolkit().getImage("imgs/peo.png");
//    添加药水图片
    Image water  = Toolkit.getDefaultToolkit().getImage("imgs/water.png");

绘制背景
case1 表示游戏运行中，需要绘制人物，加时间

//    绘制背景
    void paintSelf(Graphics g){

        g.drawImage(bg,0,200,null);
        g.drawImage(bg1,0,0,null);

        switch (GameWin.state){
//    表示整个游戏的状态  0:准备   1：运行中  2：商店  3：失败  4：胜利
            case 0:
                drawWord(g,80,Color.blue,"准备开始",200,400);
                break;

            case 1:
//                游戏运行状态才画人物等
                g.drawImage(peo,310,50,null);
                g.drawImage(water,490,40,null);

                drawWord(g,30,Color.black,"积分："+count,30,150);
                drawWord(g,30,Color.black,"*"+waterNum,550,70);

//        绘制关卡数和目标积分
                drawWord(g,20,Color.black,"第"+level+"关",30,60);
                drawWord(g,30,Color.black,"目标"+goal,30,110);

//                状态为1 实时赋值
                endTime=System.currentTimeMillis();
//                /1000 将毫秒换算成秒   20-(endTime-startTime)/1000   从20开始倒计时
                long time = 20-(endTime-startTime)/1000;
                drawWord(g,30,Color.black,"时间"+(time>0?time:0),520,110);
                break;

            case 2:
                break;
                
//            失败状态下，打印失败+积分
            case 3:
                drawWord(g,80,Color.cyan,"失败+",250,350);
                drawWord(g,80,Color.cyan,"积分+"+count,200,450);
                break;
                
//            打通五关，胜利
            case 4:
                drawWord(g,80,Color.black,"成功",250,350);
                drawWord(g,80,Color.black,"积分"+count,200,450);
                break;
            default:
        }
    }

reGame
定义重新开始游戏方法，重新定义里面的参数GameWin.java中鼠标单击事件，case4用到了 [因为case4写的是游戏胜利]

void reGame(){
//        总分
      count = 0;
//    定义存放药水数量的参数
      waterNum = 3;
//    药水状态,true表示正在使用
      waterFlag = false;
//    定义关卡
      level = 1;
//    定义每一关的目标得分
      goal = level*5;
    }

drawWord方法
背景中需要添加很多字符串，所以把绘制字符串方法单独写出来

//    绘制字符串
    public static void drawWord(Graphics graphics, int size,Color color,String str,int x,int y){
        graphics.setColor(color);
//        宋体加粗大小30
        graphics.setFont(new Font("微软雅黑",Font.BOLD,size));
//        打印字符串，当前积分，在（30，150）坐标位置上
        graphics.drawString(str+count,x,y);
    }
}

Line.java

//    起点坐标
    int x=380;
    int y=180;

//    终点坐标
    int endx=500;
    int endy=500;

//    线长
    double length = 100;

//   设置线长的最大最小值，在抓取和返回时用
    double MIN_length=100;
    double MAX_length=750;
    double n = 0;

//    添加方向参数
    int dir = 1;

//    红线状态  0：摇摆  1：抓取  2：收回  3:抓取返回
    int state;

//    添加钩爪图片
    Image hook = Toolkit.getDefaultToolkit().getImage("imgs/hook.png");

    GameWin frame;
    Line(GameWin frame){
        this.frame = frame;
    }

logic方法
红线碰到方块后需要抓上来，添加一个碰撞检测方法

//    碰撞检测
    void logic(){
//        从主窗口中拿objectList集合来遍历
        for (Object obj: frame.objectList){
            if (endx>obj.x && endx<obj.x+obj.width &&
                    endy>obj.y && endy<obj.y+obj.height){
                state=3;
//                当抓取到了，金块的值变为真
                obj.flag = true;
            }
        }
    }

lines
绘制红线方法

void lines(Graphics g){
        endx = (int) (x + length*Math.cos(n*Math.PI));
        endy = (int) (y+ length*Math.sin(n*Math.PI));
        g.setColor(Color.RED);
//        红线实现加粗功能
        g.drawLine(x,y,endx,endy);
        g.drawLine(x-1,y,endx-1,endy);
        g.drawLine(x+1,y,endx+1,endy);
//        钩爪在红线的下面，红线放置在钩爪中心位置
        g.drawImage(hook,endx-36,endy+2,null);
    }

paintSelf
绘制红线，需要判断红线的状态 [0：摇摆 1：抓取 2：收回 3:抓取返回]
当状态为0 时处于摇摆状态，dir=-1时（(n>0.9)），代表到2pi了，红线反向
try catch里意思就是，用质量来刷新，质量越小，刷新越快，视觉上就是物体拉得更快了

//    Graphics对象代表画笔
    void paintSelf(Graphics g){
//      调用判断，当绳子碰到金块时，绳子的状态时3，此时在switch中写状态3情况
        logic();
        switch (state){
            //case0 线摇摆
            case 0:
                if (n<0.1){
                    dir=1;
                }else if (n>0.9){
                    dir=-1;
                }
                n=n+0.005*dir;
                lines(g);
                break;

//                case1 抓取
            case 1:
                if (length<MIN_length){
                    length = length+5;
                    lines(g);
                }else {state=0;}
                break;
//                case2 收回
            case 2:
                if (length>MAX_length){
                    length=length-5;
                    lines(g);
                }else {state=0;}

            case 3:
                int m=1;
                if (length>MIN_length){
                    length=length-10;
                    lines(g);
//                    减去偏移量  金块长度的一半
                    for (Object obj: frame.objectList){
                        if (obj.flag==true){
//                            抓到物体之后，将物体的质量付给m
                            m=obj.m;
                            obj.x=endx-obj.getWidth()/2;
                            obj.y=endy;
                            if (length<=MIN_length){
                                //抓取成功，直接将金块移除  -150就是放在屏幕外面
                                obj.x= -150;
                                obj.y= -150;
                                obj.flag=false;
//                                计算总分,等于当前分数加上被抓物体的分数
                                Bg.count = obj.count;
                                state = 0;
                            }
                            if (Bg.waterFlag){
                                if (obj.type==1){
                                    m=1;
                                }
                                if (obj.type==2){
                                    obj.x= -150;
                                    obj.y= -150;
                                    obj.flag=false;
                                }
                            }
                        }
                    }
                }
//                把m作为刷新频率
                try {
                    Thread.sleep(m);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                break;
        }
    }

Object.java

石头类和金块类的父类，他们有公共属性熟悉写起来方便

public class Object {

// 标记,是否能移动
    boolean flag;

    //坐标
    int x;
    int y;
    //宽高
    int width;
    int height;
//    图片
    Image img;
//    质量，抓取不同的物体，返回的速度不一样
    int m;
//    绘制方法

//    添加积分
    int count;

//    类型1 石块  类型2  石块
    int type;

    void paintSelf(Graphics g){
        g.drawImage(img,x,y,null);
    }

//    Line方法中，需要获取金块石块的宽度的一般，来计算偏移量，这里定义getWidth就能在Line类的paintSelf方法中得到了
    public int getWidth() {
        return width;
    }

//判断边界方法
    public Rectangle getRec(){
        return new Rectangle(x,y,width,height);
    }

}

Gold.java

金块有三种

public class Gold extends Object{

    Gold(){
        this.x=(int) (Math.random()*700);
        this.y=(int) (Math.random()*550+300);
        this.width=52;
        this.height=52;
        this.img= Toolkit.getDefaultToolkit().getImage("imgs/gold1.gif");
//        flag 的初始值为false，代表没被抓到，不移动
        this.flag = false;
        this.m=80;
        this.count = 4;
        this.type=1;
    }

}

class GoldMini extends Gold{
    GoldMini(){
        this.width = 36;
        this.height = 36;
        this.m = 15;
        this.img = Toolkit.getDefaultToolkit().getImage("imgs/gold0.gif");
        this.count = 2;
    }
}

class GoldPlus extends Gold{
    GoldPlus(){
        this.x=(int) (Math.random()*650);
        this.width = 105;
        this.height = 105;
        this.m = 60;
        this.img = Toolkit.getDefaultToolkit().getImage("imgs/gold2.gig");
        this.count = 8;
    }
}

Rock.java

石块有一种

public class Rock extends Object{

    Rock(){
        this.x=(int) (Math.random()*700);
        this.y=(int) (Math.random()*550+300);
        this.width=71;
        this.height=71;
        this.img= Toolkit.getDefaultToolkit().getImage("imgs/rock1.png");
//        flag 的初始值为false，代表没被抓到，不移动
        this.flag = false;
        this.m = 150;
        this.count = 1;
        this.type=2;
    }

}