Table des matières
1. Description du projet QuickHit
2.2 Confirmer la saisie et afficher le résultat
1. Description du projet QuickHit
Le jeu QuickHit teste la précision et la vitesse de la saisie du joueur à partir du clavier.
Selon le taux d'entrée et le taux correct, le niveau est défini en 6 niveaux. Les joueurs commencent à partir du premier niveau et progressent étape par étape en fonction de la précision et de la vitesse du contenu d'entrée. Le temps spécifié requis par le niveau a également changé, c'est-à-dire que chaque niveau est plus difficile et les points correspondants pour chaque niveau sont également plus élevés. Si le joueur termine le nombre spécifié de sorties dans le temps spécifié et que le taux correct atteint la norme (ici, tant que vous faites une mauvaise entrée, vous quitterez) pour avancer.
2. Modules fonctionnels
2.1 Chaîne de sortie du jeu
L'étape principale consiste à générer une chaîne fixe mais aléatoire, à afficher la chaîne générée sur la console et à renvoyer cette chaîne (doit être renvoyée pour comparaison avec l'entrée du joueur).
Les étapes de mise en œuvre peuvent être conçues comme les étapes suivantes :
(1) Générer des chaînes.
(2) chaîne de sortie.
(3) Renvoie une chaîne (doit être renvoyée pour comparaison avec l'entrée du joueur).
2.2 Confirmer la saisie et afficher le résultat
Différents résultats sont générés selon que la saisie du joueur est correcte ou non. Lorsque l'entrée est correcte et n'a pas expiré, affichez le niveau actuel du joueur, les points actuels et le temps écoulé. Comment calculer le niveau actuel du joueur, les points actuels et le temps écoulé est la clé.
Les étapes de mise en œuvre peuvent être conçues comme les étapes suivantes :
(1) Confirmez que la saisie du lecteur est correcte.
(2) Si l'entrée est incorrecte, affichez directement le message d'erreur et quittez le programme.
(3) Si la saisie est correcte, les deux situations suivantes se produiront.
a : S'il expire, affichez directement les informations de délai d'attente du lecteur et quittez le programme.
b : S'il n'y a pas de délai d'attente, procédez comme suit :
Calculez le score actuel du joueur.
Calculez le temps écoulé du joueur.
Affiche le niveau actuel du joueur, les points actuels et le temps écoulé.
Déterminez si l'utilisateur a réussi le dernier niveau et traitez-le.
2.3 Les joueurs jouent au jeu
Les 6 niveaux du jeu peuvent être implémentés via des boucles, et plusieurs sorties de chaînes dans chaque niveau sont implémentées via des sous-boucles internes. Cette fonction de contrôle est placée dans la méthode play() de la classe Player. Chaque fois qu'un joueur avance, le Les points sont effacés et le chronomètre est remis à zéro.
Les étapes de mise en œuvre peuvent être conçues comme les étapes suivantes :
(1) Créez un objet Game et transmettez la propriété du joueur.
(2) Boucle extérieure (le nombre de boucles est de 6, à chaque boucle, le joueur avance d'un niveau).
une promotion.
b : Les points sont effacés, le timing est effacé.
c : Boucle interne (le nombre de boucles est le strTime de ce niveau, chaque boucle réalise une interaction homme-machine).
Chaîne de sortie du jeu.
Le joueur saisit une chaîne.
Jugez la chaîne saisie par le joueur et affichez le résultat correspondant.
3. Technologie
Utilisez le bloc de code statique pour définir et configurer les paramètres de chaque niveau, utilisez la classe de niveau pour créer un objet de niveau, stockez les paramètres de niveau correspondants pour chaque niveau et créez un objet de jeu pour représenter l'état actuel du joueur, y compris le niveau actuel. le nombre et les points actuels, l'heure de début du niveau actuel, le temps écoulé du niveau actuel, la somme de tous les points obtenus au cours des niveaux précédents, lorsque le jeu démarre, il entrera dans la boucle de la méthode play(), et le nombre de boucles est la longueur du tableau dans le bloc de code statique, qui est effacé au début de chaque niveau. Timing et points, mettent à jour le numéro de niveau et le total des points.
L'objet de jeu et l'objet de niveau sont associés à l'attribut levelNo dans l'objet de jeu.
Dans chaque niveau, imprimez d'abord la chaîne, utilisez l'objet Random pour générer aléatoirement chaque caractère de sortie, puis connectez ces caractères via l'objet StringBuffer, puis affichez-la sur la console et utilisez sa méthode toString pour renvoyer la chaîne et l'entrée. chaînes à des fins de comparaison. Comparez et utilisez if-else pour juger si la chaîne d'entrée correspond à la chaîne de sortie. Si elles ne correspondent pas, le score total actuel sera affiché puis terminé. La correspondance doit également juger si le temps utilisé par le niveau actuel a chronométré. out (la méthode pour obtenir l'heure actuelle du système en microsecondes est System .currentTimeMillis()) affichera le score total actuel, puis quittera s'il expire. S'il n'y a pas de délai d'attente, il jugera finalement s'il doit passer le niveau. Si ça passe, ça se terminera, sinon il entrera dans la sortie de la chaîne suivante.
4.Code source
La classe level stocke les attributs des niveaux correspondant à chaque niveau
package QuickHi;
public class Level {
private int level;//级别号
private int strLength;//输出字符串长度【各级别不同】
private int time;//输出字符串的频率或者次数
private int timeLimit;//各级别所需时间变量
private int perScore;//各级别输出字符串之后增加的分数变量
public Level(){ }
public Level(int level, int strLength, int time, int timeLimit, int perScore) {
this.level = level;
this.strLength = strLength;
this.time = time;
this.timeLimit = timeLimit;
this.perScore = perScore;
}
public int getLevel() {
return level;
}
public void setLevel(int level) {
this.level = level;
}
public int getStrLength() {
return strLength;
}
public void setStrLength(int strLength) {
this.strLength = strLength;
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
public int getTimeLimit() {
return timeLimit;
}
public void setTimeLimit(int timeLimit) {
this.timeLimit = timeLimit;
}
public int getPerScore() {
return perScore;
}
public void setPerScore(int perScore) {
this.perScore = perScore;
}
}
La classe LevelParam stocke les attributs statiques spécifiques correspondant à chaque niveau, qui sont tous constants, et la difficulté du jeu n'est définie qu'ici
package QuickHi;
public class LevelParam {
//定义常量 --》制定6个关卡中每个关卡的游戏规则
public static final Level levels[] = new Level[6];
//static{ }代表静态，作用：类加载的时候只加载一次，独一份
static {
levels[0] = new Level(1, 2, 5, 30, 2);
levels[1] = new Level(2, 3, 5, 30, 3);
levels[2] = new Level(3, 4, 5, 30, 4);
levels[3] = new Level(4, 5, 5, 30, 5);
levels[4] = new Level(5, 6, 5, 30, 6);
levels[5] = new Level(6, 7, 5, 30, 7);
}
}
La classe Game stocke le flux logique de l'ensemble du jeu, comprenant principalement l'impression des personnages correspondant à chaque niveau sur la console, la comparaison de chaque entrée et sortie, et le jugement de traitement correspondant après la comparaison.
package QuickHi;
//游戏类
import java.util.Random;
public class Game {
private Player player;
public Game(){}
public Game(Player player){
this.player = player;
}
/*
* 1、游戏输出字符串
* */
public String printStr(){
//获取用户当前级别号对应的字符串长度【角标从0开始，所有减1】
int strLength = LevelParam.levels[player.getLevelNo()-1].getStrLength();
//创建一个可以编辑的字符串对象StringBuffer【String对象是不可编辑的字符串对象】
StringBuffer buffer = new StringBuffer();
//创建一个随机对象
Random random = new Random();
//循环输出要输出的字符串
for (int i = 0 ; i < strLength ; i++){
//产生随机数
int rand = random.nextInt(strLength);
//拼接字符串
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;
}
}
//输出字符串
System.out.println(buffer);
//将StringBuffer类型的变量转变为String类型的对象--》toString()
String ss = buffer.toString();
return ss;
}
/*
* 2.游戏比对方式【输出的和输入的进行】
* */
public void printResult(String out,String in){
boolean flag;
//比对输出的字符串和输入的字符串
if (out.equals(in)){
flag = true;
}else {
flag = false;
}
//1、如果输入正确的话
if (flag){
//获取当前时间
long currentTime = System.currentTimeMillis();
// (currentTime - player.getStartTime())/1000 当前时间 - 起始时间 = 共使用时间
// LevelParam.levels[player.getLevelNo()-1].getTimeLimit() 当前（某个用户通过）该关卡所需时间
if ((currentTime - player.getStartTime())/1000 > LevelParam.levels[player.getLevelNo()-1].getTimeLimit()){
//1、如果超时，则显示超时，并退出jvm虚拟机
System.out.println("超时，您输入的太慢了！退出");
System.exit(1);
}else {
//2、如果没有超时
//2、1计算分数
player.setOurScore(player.getOurScore()+LevelParam.levels[player.getLevelNo()-1].getPerScore());
//2、2计算时间
player.setElapsedTime((int)(currentTime - player.getStartTime())/1000);
//2、3输出积分，级别，时间
System.out.println("输入正确，您的级别是"+player.getLevelNo()+" 您的积分："+player.getOurScore()+",已用时间："+player.getElapsedTime()+"秒");
//2、4判断用户是否已经闯过最后一关
if (player.getLevelNo() == 6){
int score = LevelParam.levels[player.getLevelNo()-1].getPerScore()*LevelParam.levels[player.getLevelNo()-1].getTime();
//如果玩家达到最高分
if(player.getOurScore() == score){
System.out.println("你当前获得的总积分为："+(player.getOurScore()+player.getSumScore()));
System.out.println("你已经闯关成功，恭喜");
System.exit(0);
}
}
}
}else {
System.out.println("你当前获得的总积分为："+(player.getOurScore()+player.getSumScore()));
System.out.println("输出错误，退出");
System.exit(0);
}
}
public Player getPlayer() {
return player;
}
public void setPlayer(Player player) {
this.player = player;
}
}
La classe Player stocke les informations relatives au joueur
package QuickHi;
import java.util.Scanner;
public class Player {
private int levelNo;//级别号
private int ourScore;//当前积分
private long startTime;//各级别开始时间
private long elapsedTime;//各级别已用时间
private int sumScore;//游戏结束时总共获得的积分
/*
* 玩家玩游戏
* */
public void play(){
Game game = new Game(this);
Scanner scanner = new Scanner(System.in);
for (int i = 0 ; i < LevelParam.levels.length ; i++){
//1.晋级
this.levelNo += 1;
//2.计时清零
this.startTime = System.currentTimeMillis();
//3.积分清零
this.ourScore = 0;
//4.以上关卡获得的总积分
this.sumScore = 0;
for (int j = 0 ; j < levelNo-1 ; j++){
this.sumScore += LevelParam.levels[j].getPerScore()*LevelParam.levels[j].getTime();
}
for (int j = 0 ; j < LevelParam.levels[levelNo-1].getTime() ; j++){
//输出字符串
String outStr = game.printStr();
//输入字符串
String inStr = scanner.next();
game.printResult(outStr, inStr);
}
}
}
public Player() {
}
public Player(int levelNo, int ourScore, long startTime, long elapsedTime) {
this.levelNo = levelNo;
this.ourScore = ourScore;
this.startTime = startTime;
this.elapsedTime = elapsedTime;
}
public int getLevelNo() {
return levelNo;
}
public void setLevelNo(int levelNo) {
this.levelNo = levelNo;
}
public int getOurScore() {
return ourScore;
}
public void setOurScore(int ourScore) {
this.ourScore = ourScore;
}
public long getStartTime() {
return startTime;
}
public void setStartTime(long startTime) {
this.startTime = startTime;
}
public long getElapsedTime() {
return elapsedTime;
}
public void setElapsedTime(long elapsedTime) {
this.elapsedTime = elapsedTime;
}
public int getSumScore() {
return sumScore;
}
public void setSumScore(int sumScore) {
this.sumScore = sumScore;
}
}
Classe de test, exécutez cette classe pour exécuter l'ensemble du programme
package QuickHi;
public class Test {
public static void main(String[] args) {
Player player = new Player();
player.play();
}
}