高分二进制文件

Question

Hi!

I would like to maintain a high score system with a maximum of 5 binary scores for my school project game. If the new value is higher than what is already in the file, I want to replace it with the new value.

I've been at it for a long time, but I'm not really getting it out. It always adds new lines and my check that the value is already in the file does not work. I hope you can help me a step further.

thanks in advance

Here's my code:

private static final String HIGHSCORE_PATH = "highscore-" + LocalDate.now() + ".dat";
    private static final Path filePath = Paths.get(HIGHSCORE_PATH);
    private final ArrayList highscoreList = new ArrayList();
    private final ArrayList highscoreFileWaardes = new ArrayList();
    FileOutputStream fos = new FileOutputStream(HIGHSCORE_PATH, true);
    int numberRulesInUse = 0;
    int teller2 = 0;
    int teller3 = 0;

public void writeHighscore(int highscore) throws IOException {
        if (Files.exists(filePath)) {
            try (Scanner fileScanner = new Scanner(filePath)) {
                if (numberRulesInUse > 6) {
                    System.out.println("File is too long");
                    return;
                } else if (numberRulesInUse == 0) {
                    for (int i = 0; i < 5; i++) {
                        highscoreList.add(0);
                    }
                } else {
                    String highscoreBinair = fileScanner.nextLine();
                    highscoreList.set(teller2, (Integer.parseInt(highscoreBinair, 2)));
                    while (fileScanner.hasNext()) {
                        if (aantalRegelsInGebruik < 5) {
                            if (!highscoreList.get(teller3).equals(highscoreFileWaardes.get(teller3))) {
                                highscoreList.set(teller3, (Integer.parseInt(highscoreBinair, 2)));
                                teller3++;
                                numberRulesInUse++;
                            } else {
                                System.out.println("Already in file");
                                return;
                            }
                        } else {
                            System.out.println("FILE DOESN'T ALLOW MORE THAN 5 RULES");
                            return;
                        }
                    }
                }
            } catch (IOException ioException) {
                throw new IOException("Error while reading file");
            }
            
            if ((Integer) highscoreList.get(teller3) < highscore && (Integer) highscoreList.get(teller3) != highscore) {
                try {
                    highscoreList.set(teller3, Integer.parseInt(String.valueOf(highscore)));
                    fos.write(Integer.toBinaryString(Integer.parseInt(String.valueOf(highscoreList.get(teller3)))).getBytes());
                    fos.write("\n".getBytes());
                    teller3++;
                    numberRulesInUse++;
                } catch (IOException e) {
                    throw new IOException("Error while writing to file");
                }
            } else {
                System.out.println("No new highscore or highscore already exists");
            }
        }
        fos.flush();
        //fos.close();
    }

Answer 1

Let's take a step back and think about what you are trying to do, and if there is an easier way to do it all.

1. Load the scores from the file to a list,
2. Add the new high score to the list if it is higher,
3. Save the top 5 new high scores,
4. Profit!

We start by reading each line of the file to an array and parsing it to an Integer existingHighScores.add(Integer.parseInt(line, 2));

The next step is to check if your score is higher or not, however, there is an far easier way to do this by simply adding the score to the end of the list existingHighScores.add(highscore); , and then we can sort the list in descending order Collections.sort(existingHighScores, Collections.reverseOrder()); that single line of code will cut out all your loops and if/else checks and give you some great readable code.

Finally, because we have a nicely sorted list we can just save the first 5 items in the list which are the 5 top scores to file, and as mentioned earlier, because the code is sorted it will remove the need to compare and remove lower scores:

    for (int i = 0; i < 5; i++)
    {
        out.write(Integer.toBinaryString(existingHighScores.get(i)).getBytes());
        out.write("\n".getBytes());
    }

---

Now if we put it all together a fully working example might look something like this:

public void writeHighscore(int highscore) throws Exception {

    //File path
    Path file = Paths.get(HIGHSCORE_PATH);
    
    //Fill arraylist with 5 0's to avoid issues if the list loaded from file is corrupt, or shorter than 5
    ArrayList<Integer> existingHighScores = new ArrayList<>(Arrays.asList(0,0,0,0,0));
    
    //Load the exising high scores
    InputStream in = Files.newInputStream(file);
    BufferedReader reader = new BufferedReader(new InputStreamReader(in)));

    String line = null;
    while ((line = reader.readLine()) != null)
    {
        //load score, of if there is an error default to 0
        try{
            existingHighScores.add(Integer.parseInt(line, 2));
        }
        catch (Exception e){
           existingHighScores.add(0);
        }
    }

    //Remember to close the file, otherwise we cant save the new scores below
    reader.close();
    in.close();

    //Add the new high score to list
    existingHighScores.add(highscore);
    
    //Sort the scores
    Collections.sort(existingHighScores, Collections.reverseOrder());

    
    //Save the highscores to file
    OutputStream out = new BufferedOutputStream(Files.newOutputStream(file)));

    //Only write the first 5 scores
    for (int i = 0; i < 5; i++)
    {
        out.write(Integer.toBinaryString(existingHighScores.get(i)).getBytes());
        out.write("\n".getBytes());
    }
}

Now you can add your exception handling and error checking if(Files.exists(file)) etc, and you can play with the code to get the file format working exactly as you want, but the logic itself remains simple and unchanged.