Текстовый блок и форматирование Println, Java: как удалить лишние строки

Это для игры в палача, и логика работает отлично — слово вставляется правильно, и палач с каждым словом вешается все больше и больше. Однако «графика» немного сложна для пользователя, как вы можете видеть ниже в выводе:

      3

[ .----------------. 
| .--------------. |
| |  _______     | |
| | |_   __ \    | |
| |   | |__) |   | |
| |   |  __ /    | |
| |  _| |  \ \_  | |
| | |____| |___| | |
| |              | |
| '--------------' |
 '----------------' ,  .----------------. 
| .--------------. |
| |  ____  ____  | |
| | |_   ||   _| | |
| |   | |__| |   | |
| |   |  __  |   | |
| |  _| |  | |_  | |
| | |____||____| | |
| |              | |
| '--------------' |
 '----------------' , .----------------.s
| .--------------. |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| '--------------' |
 '----------------'\, .----------------.s
| .--------------. |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| '--------------' |
 '----------------'\,  .----------------. 
| .--------------. |
| |     ____     | |
| |   .'    `.   | |
| |  /  .--.  \  | |
| |  | |    | |  | |
| |  \  `--'  /  | |
| |   `.____.'   | |
| |              | |
| '--------------' |
 '----------------' , .----------------.s
| .--------------. |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| '--------------' |
 '----------------'\, .----------------.s
| .--------------. |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| '--------------' |
 '----------------'\,  .----------------. 
| .--------------. |
| |  _______     | |
| | |_   __ \    | |
| |   | |__) |   | |
| |   |  __ /    | |
| |  _| |  \ \_  | |
| | |____| |___| | |
| |              | |
| '--------------' |
 '----------------' ,  .----------------. 
| .--------------. |
| |     ____     | |
| |   .'    `.   | |
| |  /  .--.  \  | |
| |  | |    | |  | |
| |  \  `--'  /  | |
| |   `.____.'   | |
| |              | |
| '--------------' |
 '----------------' , .----------------.s
| .--------------. |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| |              | |
| '--------------' |
 '----------------'\]

Как сделать его плоским? В трех полях ниже показан соответствующий код того, как он был создан.

      if (word.contains(guess)) {
                                for (int location = 0; location < word.length(); location++) {
                                    String letter = String.valueOf(word.charAt(location));
                                    if (letter.equalsIgnoreCase(guess)) {
                                        progressOnWord.set(location, guess);
                                    }
                                }
                                numberCorrect++;
                                p(numberCorrect);
                        }

                

Вышеприведенный код заполняет ArrayList, progressOnWord, когда есть правильное слово. progressOnWord начинается как «0000000000», то есть столько нулей, сколько символов в слове, которое можно угадать. Он заполняется правильными буквами, если они угаданы, например:

"rh00o00ro0" на текущем этапе, показанном выше. Затем он преобразуется в ASCII: если строка равна 0, добавьте пустой блок ASCII в ASCIIform, форму ASCII progressOnWord. Например, если progressOnWord имеет значение rh00o00ro0, то блок ASCII будет таким, как вы видите выше. Установка пробела не имеет значения — не важно, в каком месте находится пробел, он просто устанавливает все 0 в пробелы.

      for (int j = 0; j < progressOnWord.size(); j++) {
                            String wordPlace = progressOnWord.get(j);
                            if (wordPlace.equals("0")) {
                                ASCIIform.set(j, ASCIIblank);
                            }

Это утверждение избирательно, оно гарантирует, что буква находится в нужном месте.

      for (int k = 0; k < lowercase.length; k++) {
                            String letter = String.valueOf(lowercase[k]);
                            String ASCIIletter = ASCIIalphabet[k];
                            if (wordPlace.equalsIgnoreCase(letter)) {
                                ASCIIform.set(j, ASCIIletter);
                            }
                        }
                        }

Обратите внимание, что два блока кода являются непрерывными, но разделены здесь для комментариев. Итак, вернемся к вопросу: почему блоки располагаются каждый на новой строке и как это исправить? Получает блоки из ArrayList<String>(сжато ниже):

      public static String[] getASCIIalphabet() {
        String[] ASCIIalphabet = {
                """
 .----------------.\s
| .--------------. |
| |      __      | |
| |     /  \\     | |
| |    / /\\ \\    | |
| |   / ____ \\   | |
| | _/ /    \\ \\_ | |
| ||____|  |____|| |
| |              | |
| '--------------' |
 '----------------'\s""",

                """
 .----------------.\s
| .--------------. |
| |   ______     | |
| |  |_   _ \\    | |
| |    | |_) |   | |
| |    |  __'.   | |
| |   _| |__) |  | |
| |  |_______/   | |
| |              | |
| '--------------' |
 '----------------'\s"""
};

Может ли форматирование ArrayList быть проблемой? Как если бы у вас было

      "0",
"1",
"2",

в ArrayList будет ли он печатать следующее?

      0
1
2

Я так не думаю. Это из-за добавления блоков? Они добавляются 1 на 1 по мере их угадывания, это вызывает наложение? Или это какой-то символ в самих блоках — в текстовых блоках в алфавите ArrayList, возможно, это \s?

Чтобы предоставить более подробную информацию об ответе Дэниела,

и используются.

Вот код:

      for (int j = 0; j < progressOnWord.size(); j++) {
                                String wordPlace = progressOnWord.get(j);
                                if (wordPlace.equals("0")) {
                                    ASCIIform.set(j, ASCIIblank);
                                }
                                
                            

выше, поскольку 0 является заполнителем, когда встречается 0, он заменяется пробелом блока ASCII:

                                                   '----------------'
                                            | .--------------. |
                                            | |              | |
                                            | |              | |
                                            | |              | |
                                            | |              | |
                                            | |              | |
                                            | |              | |
                                            | |              | |
                                            | '--------------' |
                                             '----------------'\, 


        
                                      for (int k = 0; k < lowercase.length; k++) {
                                    String letter = String.valueOf(lowercase[k]);
                                    String ASCIIletter = ASCIIalphabet[k];
                                    if (wordPlace.equalsIgnoreCase(letter)) {
                                        ASCIIform.set(j, ASCIIletter);
                                    }
                                }
                            


                          

Приведенный выше код перебирает алфавит в цикле, который перебирает каждый символ в слове. например, с «rhinoceros»: если прогресс равен rh00o00ro0, он проверяет, равно ли r 0. Нет. Затем он переходит к итерации через a, b, c...z, пока не найдет r. когда он находит r в алфавите, он отмечает, что r находится в позиции 0 в процессе выполнения, и отмечает, что r является 18-й буквой в алфавите, и продолжает устанавливать позицию 0 в слове ASCII на 18-ю строку в алфавите блоков ASCII. :

                                                      [ .----------------.
                                                | .--------------. |
                                                | |  _______     | |
                                                | | |_   __ \    | |
                                                | |   | |__) |   | |
                                                | |   |  __ /    | |
                                                | |  _| |  \ \_  | |
                                                | | |____| |___| | |
                                                | |              | |
                                                | '--------------' |
                                                 '----------------' ,
                             

Необходимо использовать ArrayList.set(int index, String element)метод, потому что местоположение персонажа имеет значение в этой игре.

Наоборот, StringBuilder.append(char c)используется при создании демонстрации преобразования ASCII; если пользователь ввел «rhinoceros», он печатает полное слово «rhinoceros» в блочном стиле ASCII, который вы видите выше, чтобы дать пользователю почувствовать вкус «графического» стиля. Вот код:

                              for (int i = 0; i < allCaps.length(); i++) {
                            char c = allCaps.charAt(i);
                            for (int j = 0; j < uppercase.length; j++) {
                                char bigChar = uppercase[j];
                                String ASCIIblock = getASCIIalphabet()[j];
                                if (c == bigChar) ASCIIword.append(ASCIIblock);
                            }
                        }

Стоит отметить, что StringBuilder.append()а также ArrayList.set()дают тот же результат: штабелирование. Есть ли выход или "боком"? append()а также set()методы по умолчанию укладывают буквы; кажется, это должно быть что-то с форматированием текстовых блоков в ArrayList. Хотя горизонтальное значение обычно используется по умолчанию, можно ли волей-неволей принудительно добавить/установить горизонтальное направление, чтобы получить R---->H---->I---->N...?

1 ответ

Теперь я понимаю вашу проблему, проблема в том, что вы добавляете строки после рисования каждого символа, что означает, что вы не можете вернуться к той же строке, чтобы нарисовать другой символ, поэтому вместо этого вы можете сохранить каждую строку в символе в массиве строк ( String[]) в исходном ArrayList, поэтому он будет ArrayList<String[]>и вы можете перебирать каждую первую строку символа, взгляните на этот код, который я сделал, чтобы решить проблему:

      final int numberOfLines = 11;
for (int i = 0; i < numberOfLines; i++) {
    for (int j = 0; j < asciiForm.size(); j++) {
        String[] word = asciiForm.get(j);
        System.out.print(word[i]);
    }
    System.out.println("\t");
}

Пример того, как будет выглядеть символ в ArrayList:

         asciiForm.add(
                new String[] { 
                        " .----------------. ", 
                        "| .--------------. |", 
                        "| |  _______     | |", 
                        "| | |_   __ \\    | |", 
                        "| |   | |__) |   | |", 
                        "| |   |  __ /    | |", 
                        "| |  _| |  \\ \\_  | |", 
                        "| | |____| |___| | |", 
                        "| |              | |", 
                        "| '--------------' |", 
                        " '----------------' "
                }

        );

Результат, который я получил:

Примечание. Я не добавлял все символы в ArrayList, потому что мне это не нужно, я добавил только R и H.

Другие вопросы по тегам