QuickHit游戏项目总结

package hit;

import java.util.*;

public class Game {

//需要一个玩家
private Player player;

//如果你要开启一局游戏，一定要给游戏对象一个玩家对象，才能创建这个游戏对象
//提供一个带玩家作为参数的构造方法
public Game(Player player){

this.player = player;
}

//方法：
/*
* 1.生成一个对应玩家级别的字符串
* String 方法名（）{
* 
* }
* 
* */
public String printStr(){

//生成字符串的方法内容 TODO
//1.0获取到玩家等级
int levelNo = player.getLevelNo() - 1;

//1.1 获取到当前玩家等级 下对应的字符串长度
int strlen = LevelInitial.levelsArr[levelNo].getStrlength();

//1.2 创建随机数对象
Random random = new Random();

//创建一个StringBuffer 对象，用来不断的存储和改变字符串内容
StringBuffer buffer = new StringBuffer();

//1.3 采用循环 加上判断的方式， 生成对应长度的字符串
for(int i = 0; i < strlen; i++){

//1.4 每循环一次产生一个随机数
int rand = random.nextInt(strlen);

//1.5 将这个 随机数对应的字符 拼接
switch(rand){

case 0:
buffer.append("<");
break;
case 1:
buffer.append(">");
break;
case 2:
buffer.append("&");
break;
case 3:
buffer.append("*");
break;
case 4:
buffer.append("%");
break;
case 5:
buffer.append("#");
break;
case 6:
buffer.append("@");
break;

}

}

//1.6 字符串已经生成好了，先给用户看
System.out.println(buffer);

//1.7 返回这个做好的字符串
return buffer.toString();
}

/*
* 2.对比 原本的结果 和 玩家输入的结果， 
* void 方法名(String 原本的字符串， String 玩家输入的字符串){
* 
* }
* */

public void result(String out, String in){
//TODO --》 对比玩家结果和原本的结果， 判断玩家是否可以继续游戏
//1.判断结果是否一致
/*
* if(结果一样 out 跟 in一样的){
* 
*一样的不够， 时间是否超时
*
*   if（没有超时）{
*   
*      // 显示当前玩家的 积分，用时时长，当前级别
*   
*   }else{
*   
*     因为超时了，所以也是一样的 Game Over
*   
*   }
*
* 
* }else{
* 
*   不一样， 游戏终结，Game over
* }
* 
* 
* 
* */

if(out.equals(in)){ //输入 和 输出一样的

//再来判断是否超时

// 用的时间，是比 规定的时间短
// 当前时间 -- 开始时间 的差值  去比较 对应等级所规定的时间
//1.获取到当前时间戳
/*
*是 System类中的一个静态方法
*
*返回值类型是 long， 参数类型 没有
*
*返回的值  是 当前操作系统时间与 1970年1月1日0点0分的 时间间隔，以毫秒为单位 
* */
long currentTime = System.c
4000
urrentTimeMillis();

//2.获取到 开始游戏时的时间戳 

if((currentTime - player.getStartTime())/ 1000 <= LevelInitial.levelsArr[player.getLevelNo() -1].getTimeLimit()){
//没有超时
//1.1 计算分数
int newScore = player.getScore()+ LevelInitial.levelsArr[player.getLevelNo() -1].getPerScore();
//设置给玩家 --》 因为玩家有了新的分数
player.setScore(newScore);

//1.2 计算已经用的时间
long time = (currentTime - player.getStartTime())/ 1000;
//设置给玩家的 用时
player.setElapseTime(time);

//1.3 输出 时间，分数，和等级
System.out.println("输入正确，您的等级是：" + player.getLevelNo() + ", 您的积分是：" + player.getScore() + "， 您的用时为：" + player.getElapseTime() + "秒");

//1.4 判断是否已经全部通关
if(player.getLevelNo() == 6){

//进来这里， 还有五次
//第6局还有5次要玩，
//计算全部游戏 通关，应该是多少分， 然后对比分数，就知道是否通关了
//int score = LevelInitial.levelsArr[6 - 1].getPerScore() * LevelInitial.levelsArr[5].getStrTime();
  
int sum = 0;

for(int j = 0; j < LevelInitial.levelsArr.length; j++ ){ //计算总分 -- 
   
    //每个级别 的总分
    int currentScore = LevelInitial.levelsArr[j].getPerScore() * LevelInitial.levelsArr[j].getStrTime();
   
    //所有级别都通关的总分
    sum += currentScore;
   
   }

if(player.getScore() == sum){//总分一致，代表通关了

System.out.println("恭喜您全部通关！！真棒！！");
System.exit(0);
}

}

}else{//代表 着 输入正确，但是 超时了，
System.out.println("输入正确，但是时间超时，游戏结束！！游戏退出！！");
System.exit(1);
}

}else{ //代表 输入不对， 直接退出程序
System.out.println("输入错误，游戏结束！！游戏退出！！");

//真的让程序退出运行
/*
* static void exit(n)
* 返回值类型为 空
* 参数类型 int n --》 状态码， 非0代表 非正常退出
* 
* 作用：终止当前正在运行的 JVM
* */
System.exit(1);

}

}

}

package hit;

/*

 * 这个Level类的功能，是存储对应的基本的要求信息

 * 

 * 玩游戏: 1.如果你是第一级别，那么你的游戏时间会比较长，字符串比较短，每一局的分数比较低

 * 

 * 2.伴随着不一样级别的变化，你的时间是不一样的，分数不一样的，字符串长度不一样。。。

 * 

 * 因此，用级别类的对象来存储这些信息， 一个级别对象，代表一个级别

 * 

 * 如果有6个级别，就new 6个级别对象， 每个对象存储的属性值 是不一样的

 * 

 * */

public class Level {

//1.级别编号
private int levelNo;

//2.当前级别对应的 字符串长度
private int strlength;

//3.当前级别对应的输入时间限制要求
private int timeLimit;

//4.当前级别限制的 次数
private int strTime;

//5.当前级别对应的 分数
private int perScore;

/*
* 因为每个级别，应该是一来是就规定好这些 游戏初始的内容，所以不提供setter
* 
* 一次构造之后，不允许再更改它
* */
public Level(int levelNo, int strlength, int timeLimit, int strTime, int perScore){

this.levelNo = levelNo;
this.strlength = strlength;
this.timeLimit = timeLimit;
this.perScore = perScore;
this.strTime = strTime;
}

//每个级别对象 代表一个级别， 我们需要获取到这个值，
public int getLevelNum(){

return this.levelNo;
}

    public int getTimeLimit(){

return this.timeLimit;
}

    

     public int getStrTime(){

return this.strTime;
}

     public int getStrlength(){

 

  return this.strlength;

  }

     

     public int getPerScore(){

 

  return this.perScore;

  }

}

package hit;

/*

 * 这个类 是来进行每个级别对象 的初始化

 * 

 * 因为一个级别对象，存储一个级别对应的信息

 * 例如级别对象

 * Level firstLevel = new Level(1, 2, 30, 5, 1);

 * 

 * Level secondL = new Level(2, 3, 25, 6, 2);

 * 

 * Level thirdL = new Level(3, 4, 20, 7, 5);

 * 

 * Level forthL = new Level(4, 5, 15, 8, 10);

 * 

 * 所以，当前这个 LevelInital这个类的目的，是为了初始化出 所有等级的信息

 * */

public class LevelInitial {

//把所有的等级放入到数组中
//类变量，--》属于类，在类被加载的时候，创建这个数组
public static Level[] levelsArr = new Level[6];

//静态初始化块
//在加载类的时候执行静态初始化块，并且只会被执行一次
static {

levelsArr[0] = new Level(1, 2, 30, 5, 1);
levelsArr[1] = new Level(2, 3, 25, 4, 2);
levelsArr[2] = new Level(3, 4, 22, 3, 5);
levelsArr[3] = new Level(4, 5, 20, 3, 8);
levelsArr[4] = new Level(5, 6, 18, 3, 10);
levelsArr[5] = new Level(6, 7, 15, 3, 15);
}

}

package hit;

import java.util.*;

public class Player {

//属性

//1.级别号 当前这个玩家在哪一个级别
private int levelNo;

//2.开始游戏的时间
private long startTime;

//3.积分
private int score;

//4.每级别游戏的持续时间
private long elapseTime;

/*
* setter
* 
* */
public void setLevelNo(int levelNo){

this.levelNo = levelNo;
}

public void setScore(int score){

this.score = score;
}

    public void setStartTime(long time){

this.startTime = time;
}

    public void setElapseTime(long elapse){

   this.elapseTime = elapse;

    }
/*
* getter
* */

    public int getLevelNo(){

   

    return this.levelNo;

    }

    

    public int getScore(){

   

    return this.score;

    }

 

    public long getStartTime(){

 

      return this.startTime;

    }

 

    public long getElapseTime(){

 

      return this.elapseTime;

    }

    /*

     * 玩家的行为：  玩游戏

     * 

     * */

    

    public void play(){

    //玩游戏的逻辑在这里实现

   

   

    //1.首先需要一局游戏

    // this当前这个方法的调用者 --》 Player p

    //Game（Player player）

    Game game = new Game(this);

   

    //2.输入对象创建

    Scanner input = new Scanner(System.in);

   

    //3.开始游戏

    /*

    * 外层循环 是 总级别数，内层循环是每个级别 所对应的次数

    * 

    * */

    //外层循环，所有的游戏级别

    //每一次执行一次外层循环，代表玩家 玩通了一个级别，级别+1

    for(int i = 0; i < LevelInitial.levelsArr.length; i++){

   

    //1.1 玩家级别 +1

    //晋级

    levelNo += 1;

   
aa1a

    //1.2获取新的开始时间。。。

    //TODO

    startTime = System.currentTimeMillis();

   

    //1.这里代表 每个级别单独计分数

    //分数可以在这里清零

    //score = 0;

   

    //根据当前的级别，来看 这个级别下 要玩多少次

    //例如玩家在 第一级别，那么在规定的30秒内 玩8次游戏

    //例如 玩家在 第二级别，那么在规定的30秒内 玩 7次游戏

    for(int j = 0; j < LevelInitial.levelsArr[levelNo -1].getStrTime();j++){

   

    //玩游戏

    //1.1 生成字符串

    String out = game.printStr();

   

    //1.2 玩家输入字符串

    String in = input.next();

   

    //1.3 比较结果

    game.result(out, in);

   

    }

    }

    }

}

public class Test {

public static void main(String[] args){

//创建玩家，玩游戏
Player p = new Player();

p.player();
}

}

老师布置的作业是一个游戏项目，我看了一遍，愣是没有看懂

然后我就放弃了，今天老师讲了之后，我还是有许多没懂的，可是我明白了大致的结构

不像昨天，什么也不知道，老师告诉我们，不去思考就什么也不会懂

我感触很深，意思到自己的错误，在仔细去看了一遍之后，发现我虽然不能完全写出来

可也能画一个构架出来，是我自己太容易放弃了。

以后一定要改正这个错误，做什么都要努力的去尝试！

这道题目，首先阅读题目，了解意思，明白需求是什么，要达到什么样的目的

其次，分析出需要哪几个类，比如玩家这个类，等级这个类

然后试着写出每个类需要什么，比如等级这个类，需要的是次数，时间等

然后完善其中的细节。

最后再写一个测试类，用来测试其中的错误。

每一个项目都该如此。