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.currentTimeMillis();

//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;
   
    //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();
}
}

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

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


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


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


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


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






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


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


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


然后完善其中的细节。


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


每一个项目都该如此。