В этом руководстве вы:
- Познакомитесь с общими элементами компьютерной игры.
- Будете отслеживать состояние компьютерной игры.
- Научитесь получать и обрабатывать данные, вводимые пользователем.
- Создадите текстовый пользовательский интерфейс (TUI) для своей игры.
- Узнаете, когда игра закончится и кто станет победителем.
Чтобы извлечь максимум пользы из этого урока, вам желательно уметь работать с множествами и списками в Python. Вам не обязательно иметь какие-либо предварительные знания о написании игр.
Статьи по теме:
- 🐍 Самоучитель по Python для начинающих. Часть 5. Методы работы со списками и списковыми включениями
- 🐍 Самоучитель по Python для начинающих. Часть 6: Методы работы со словарями и генераторами словарей
Весь код, который вы напишете в этом уроке, доступен для скачивания по ссылке ниже:
Получите свой код: Кликните здесь, чтобы загрузить исходный код для создания игры «Виселица» на Python.
Описание проекта
Первый шаг к созданию качественной компьютерной игры – это разработка правильного дизайна. Итак, дизайн вашей игры «Виселица» следует начать с хорошего описания самой игры. Вам также необходимо иметь общее представление об элементах, из которых состоит компьютерная игра. Эти два пункта имеют решающее значение в разработке удачного дизайна.
Описание игры «Виселица»
Хотя многие люди хорошо знают эту игру, полезно знать ее правила. Как и многие другие вещи в жизни, точное описание игры «Виселица» может варьироваться от источника к источнику. Вот один из возможных вариантов описания игры:
- Подготовка к игре: Игра «Виселица» рассчитана на двух или более игроков, включая ведущего и одного или нескольких отгадывающих участников.
- Выбор слова: Ведущий игры выбирает слово, которое пытаются угадать отгадывающие игроки.
- Выбранное слово традиционно изображается в виде серии подчеркиваний каждой буквы в слове.
- Ведущий игрок также рисует подмостки, на которых будет держаться иллюстрация виселицы.
- Отгадывание: Игроки пытаются отгадать слово, выбирая буквы по одной.
- Обратная связь: Ведущий игрок указывает, встречается ли в слове та или иная названная буква.
- Если буква встречается, то ведущий игрок заменяет каждое подчеркивание на букву, которая встречается в слове.
- Если буква не фигурирует, то ведущий игрок заносит ее в список отгаданных букв. Затем он рисует следующую часть повешенного. Чтобы нарисовать повешенного, начинают с головы, затем туловище, руки и ноги – всего шесть частей.
- Условия победы: Ведущий игрок выигрывает, если рисунок повешенного завершен после шести неправильных предположений, в этом случае игра заканчивается. Отгадывающие игроки выигрывают, если угадывают слово.
- Если догадка верна – игра заканчивается, и отгадывающие игроки выигрывают.
- Если же предположение неверно, то игра продолжается.
Ниже изображена игра в процессе. В этой игре слово, которое нужно отгадать – это hangman (палач, виселица):
В этом руководстве, чтобы написать игру «Виселица» на Python, вы должны принять несколько дополнительных решений:
- Игра будет проходить между компьютером и одним игроком-человеком.
- Компьютер будет выступать в роли выбирающего игрока и будет выбирать слово для отгадывания, обрабатывать вводимые человеком данные и выводить все результаты.
- Игрок-человек – это угадывающий игрок, далее именуемый просто игроком. Когда игрок знает слово, он продолжает угадывать правильные буквы до тех пор, пока слово не будет составлено полностью.
Имея необходимое представление об игре и некоторые дизайнерские решения для компьютерной версии, вы можете приступить к созданию игры. Для начала, однако, вам нужно ознакомиться с общими элементами компьютерных игр и понять, как они взаимодействуют, чтобы получить желаемый результат.
Основные элементы компьютерной игры
В каждой игре, независимо от того, компьютерная она или нет, заложен набор элементов, которые делают ее игрой. Без этих составляющих игры не существует:
1. Начальная настройка: Вы подготавливаете игру к запуску. Это может быть расстановка фигур на шахматной доске, раздача карт или бросание костей, чтобы узнать, чей ход будет первым.
2. Игровой процесс: Когда люди представляют себе игру, они обычно думают о ней. Ход игрового процесса контролируется геймплейным циклом, который заставляет игру двигаться в нужном направлении и не прекращается до тех пор, пока игра не закончится. Игровой цикл обеспечивает выполнение следующих действий:
- Сбор и обработка пользовательского ввода.
- Состояние игры корректируется в зависимости от полученных вводимых пользователем данных. В том числе проверяются условия завершения игры.
- Вносятся необходимые изменения в выводимые данные, которые отражают обновленное состояние игры.
- Цикл игры повторяется.
3. Окончание игры: То, как закончится игра, зависит от самой игры. Будь то взятие короля противника при шахе, достижение определенного счета в карточной игре или пересечение вашей фигурой линии в настольной игре – все это определяет окончание игры и победителя при соблюдении ряда условий.
Во всех играх присутствует игровой цикл. К примеру, в шахматной игре вы сначала расставляете фигуры на доске и определяете игрока, который начинает партию. Затем запускается цикл игры:
- Текущий игрок перемещает фигуру, обновляя состояние игры.
- Проверяется условие «шах и мат», чтобы определить, закончилась ли игра.
- Текущий игрок обновляется, и цикл начинается снова.
В реальных играх границы между отдельными элементами игры размыты. Например, ходы в шахматах содержат информацию как о состоянии игры, так и о ее результатах. Несмотря на это, ключевые элементы игры всегда присутствуют. Помня о них, вы можете приступить к написанию своей первой версии «Виселицы» на Python.
🐍 Подписывайтесь на еженедельную email-рассылку, посвященную последним открытиям и тенденциям в мире Python.
В ней:
- Новые возможности в последних версиях Python
- Работа с базами данных и SQL в Python
- Веб-разработка на Django и Flask
- Машинное обучение и анализ данных с помощью Python
- Автоматизация и работа с API на Python
- Тестирование и отладка кода на Python
- Задачи для новичков с решениями
Предварительные настройки
Для создания проекта, который вы будете изучать в этом руководстве, потребуется знакомство с общим программированием на Python. Вы должны обладать базовыми знаниями по следующим темам:
- Работа с файлами и оператором
with - Получение и обработка пользовательского ввода с помощью встроенной функции
input() - Определение ваших собственных функций
- Написание циклов
whileиfor - Работа с условными операторами
- Работа со строками, списками и множествами в Python
Однако если у вас еще нет всех этих знаний, не беда! Вы можете узнать больше, если попробуете разобраться в проекте. Вы всегда можете остановиться и ознакомиться с ресурсами по ссылке, если запутаетесь.
После этого краткого обзора проекта «Виселица» и выполнения необходимых условий, вы можете приступать к изучению языка и весело проводить время за написанием кода.
Шаг 1: Настройка проекта «Виселица»
Ваша игра «Виселица» будет подбирать слово, обрабатывать вводимые пользователем данные и отображать все результаты с помощью текстового пользовательского интерфейса. Для выполнения каждой из этих задач вам понадобится код. Тем не менее, вы будете использовать встроенные и стандартные библиотеки. Вам не нужно будет устанавливать никаких дополнительных компонентов.
Для написания игры вы будете использовать один файл под названием hangman.py. Этот файл будет содержать весь необходимый код для работы игры. Просто создайте этот файл в вашем любимом редакторе кода или IDE.
Далее необходимо создать файл words.txt. Этот файл будет содержать словарь, из которого игра будет выбирать подходящее слово.
prettiest
close
dog
massive
hollow
cultured
seashore
explode
dizzy
minister
competent
thoughtful
harbor
tidy
dance
children
zesty
clean
ball
nostalgic
plan
week
strap
board
slope
bat
steep
mourn
cat
girl
ancient
street
mice
dare
wasteful
tub
limping
whimsical
eager
eggs
detail
experience
beds
train
place
cows
admit
rare
respect
loose
group
enjoy
internal
macabre
imported
superb
crooked
confused
hug
feigned
unkempt
coal
meddle
hapless
country
zealous
sick
pray
lake
tiny
key
empty
labored
delirious
ants
need
omniscient
onerous
damp
subtract
sack
connection
toad
gather
record
new
trashy
flow
river
sparkling
kneel
daughter
glue
allow
raspy
eminent
weak
wrong
pretend
receipt
celery
plain
fire
heal
damaging
honorable
foot
ignorant
substance
box
crime
giant
learned
itchy
smoke
likable
station
jaded
innocent
dead
straw
tray
chin
pack
geese
guess
wealthy
slippery
book
curly
swing
cure
flowers
rate
ignore
insidious
necessary
snakes
entertaining
rich
comb
lamentable
fuel
camera
multiply
army
exist
sulky
brief
worried
third
magical
wary
laborer
end
somber
authority
rainstorm
anxious
purpose
agreeable
spiky
toe
mixed
waiting
hungry
lopsided
flagrant
windy
ground
slap
please
white
hurry
governor
abandoned
reject
spiritual
abrasive
hunt
weather
endurable
hobbies
occur
bake
print
tire
juicy
blush
listen
trousers
daffy
scarecrow
rude
stem
bustling
nail
sneeze
bellicose
love
Вы также можете скачать полный исходный текст игры «Виселица», включая файл words.txt, по этой ссылке.
С этой начальной настройкой вы готовы приступить к написанию кода. Первым шагом будет написание функции для выбора слова, которое нужно угадать в игре «Виселица».
Шаг 2: Выберите слово для отгадывания
Первый шаг в игре в виселицу – выбор слова для отгадывания. Когда человек выбирает слово для игры в виселицу, он выбирает одно слово из своего словарного запаса. Для того чтобы компьютер мог выбрать слово, ему необходимо иметь словарь, из которого можно было бы выбирать. Конечно, его словарный запас не должен быть таким большим, как у человека.
Как же выбрать одно слово из списка? Вот одно из возможных решений:
# hangman.py
from random import choice
def select_word():
with open("words.txt", mode="r") as words:
word_list = words.readlines()
return choice(word_list).strip()
В этом фрагменте кода вы используете функцию select_word() при выборе слова для отгадывания из файла words.txt. Вы применяете оператор with для открытия файла и метод .readlines() для составления списка слов.
Затем вы используете функцию random.choice(), чтобы выбрать случайное слово из списка. Обратите внимание, что все слова в файле написаны строчными буквами. Эта деталь сыграет важную роль позже, когда вам понадобится сравнить буквы в заданных словах с введенными игроком.
Вот как работает функция select_word():
>>> from hangman import select_word
>>> select_word()
'toad'
>>> select_word()
'daffy'
>>> select_word()
'insidious'
Каждый раз, когда вы вызываете функцию, вы будете получать случайное слово из вашего словаря. Это первый шаг в создании игры «Виселица».
Использование отдельной функции для работы со словарем и выбором слов облегчает последующее изменение или расширение списка слов. Это также делает ваш код более читабельным для других или для самого себя через несколько месяцев.
Шаг 3: Получение и обработка вводимых игроком данных
Теперь вам необходимо найти способ получить информацию о догадках игрока в командной строке. В конце концов, игра – это не игра, если в ней нет возможности повлиять на результат.
В игре «Виселица» вам нужно получить данные от игрока и убедиться, что они верны. Помните, как вы создавали список слов? Все слова были написаны строчными буквами, поэтому вы должны превратить угаданные игроком слова в такие же строчные буквы.
При этом игрок не должен угадывать одну и ту же букву дважды. Также было бы неплохо избегать цифр, специальных символов и целых слов.
Итак, вам необходимо решение, состоящее из двух частей. Первая часть будет принимать входные данные игрока, а вторая – проверять их. Вы можете получить входные данные для командной строки с помощью встроенной функции input():
# hangman.py
# ...
def get_player_input(guessed_letters):
while True:
player_input = input("Guess a letter: ").lower()
if _validate_input(player_input, guessed_letters):
return player_input
Здесь приведен пример цикла обработки вводимых данных, который можно использовать для ограничения ввода пользователем. Цикл повторяется до тех пор, пока игрок не предоставит правильные значения. В данном случае это означает одну букву, которую игрок еще не угадал.
Для начала вы используете player_input для вводимых игроком строчных букв. Затем вы передаете угаданную букву в _validate_input() вместе с параметром guessed_letters. Ниже приведен код дополнительной функции _validate_input():
# hangman.py
import string
# ...
def _validate_input(player_input, guessed_letters):
return (
len(player_input) == 1
and player_input in string.ascii_lowercase
and player_input not in guessed_letters
)
Функция _validate_input() выполняет три независимые процедуры проверки. Она удостоверяется в том, что:
- Введен ровно один символ.
- Введена строчная буква от a до z включительно.
- Вводимая буква не является буквой, которую игрок уже угадал.
Чтобы функция могла вернуть True, все эти условия должны быть истинными. Если хотя бы одно из этих условий ложно, то функция возвращает False, и цикл ввода перезапускается. Вот как работает новый код:
>>> from hangman import get_player_input
>>> get_player_input({"a", "b"})
Guess a letter: 3
Guess a letter: e
'e'
>>> get_player_input({"a", "b"})
Guess a letter: a
Guess a letter: f
'f'
Когда вы вызываете get_player_input() с множеством, содержащим ранее угаданные буквы, вы получаете подсказку, которая просит вас ввести букву. Если вы вводите небуквенный символ или ранее угаданную букву, функция отклоняет ее, поскольку она не является допустимой. Затем подсказка появляется снова. Когда вы вводите корректную букву, вы получите ее обратно.
Теперь у вас есть способ принимать и проверять вводимые игроком данные. Пришло время решить, как остановить игру!
Шаг 4: Отображение угаданных букв и слова
После того как вы выбрали подходящее слово в игре «Виселица», вам необходимо отметить каждую букву в слове подчеркиванием или пробелом. Эти пробелы подскажут игрокам, сколько букв в заданном слове. В то время как игроки отгадывают, вы заполняете пробелы подходящими буквами. Вы также должны следить за ошибками, которые вы записываете отдельно.
Итак, теперь у вас будет две задачи:
- Вывести на экран буквы, которые угадал игрок.
- Отобразить правильные буквы на соответствующих местах в слове.
Чтобы отслеживать угаданные игроком буквы, вы будете использовать множество Python. Использование множества позволяет эффективно проверять, угадал ли игрок определенную букву с помощью тестов принадлежности с оператором in.
Для отображения угаданных букв используется метод .join():
# hangman.py
# ...
def join_guessed_letters(guessed_letters):
return " ".join(sorted(guessed_letters))
Метод .join() используется для создания единой строки, состоящей из элементов множества guessed_letters, разделенных пробельным символом. Встроенная функция sorted() позволяет упорядочить отгаданные буквы в алфавитном порядке.
Для создания слова, которое нужно будет угадать игроку, используется другая функция:
# hangman.py
# ...
def build_guessed_word(target_word, guessed_letters):
current_letters = []
for letter in target_word:
if letter in guessed_letters:
current_letters.append(letter)
else:
current_letters.append("_")
return " ".join(current_letters)
Эта функция использует цикл for для создания списка current_letters. Цикл проверяет каждую букву в заданном слове и определяет, встречается ли эта буква в списке угаданных значений. Если это так, то программа добавляет букву в current_letters. Если нет, то в current_letters добавляется знак подчеркивания _. Затем вы используете метод .join() для создания отображаемого слова, которое будет включать правильные буквы в соответствующих местах.
Попробуйте использовать эти две функции. Помните, что вы должны использовать множество угаданных букв и заданное слово.
Шаг 5: Нарисуйте висельника
Конечно же, не существует игры в виселицу без настоящего повешенного, не так ли? Вы можете просто вывести количество угаданных игроком букв. Но если вы хотите, чтобы игра была похожа на виселицу, то показать повесившегося человека – хорошая идея.
В этом разделе вы займетесь созданием изображения повешенного с помощью ASCII-символов. Ваше решение состоит из списка, содержащего семь различных строк. Первая строка будет представлять строительные леса, а шесть оставшихся – части тела повешенного:
- Голова
- Туловище
- Правая рука
- Левая рука
- Правая нога
- Левая нога
Для создания различных состояний виселицы вы будете использовать исходные строки. Необработанные строки требуют наличия символа r перед открывающей кавычкой. Эти строки не будут рассматривать обратные слеши \ как специальные символы, поэтому вы можете использовать их в иллюстрациях. Обратите внимание, что вы будете использовать количество неправильных предположений в качестве индекса при выборе строки для отображения.
Ниже приведен код создания повешенного человека:
# hangman.py
# ...
def draw_hanged_man(wrong_guesses):
hanged_man = [
r"""
-----
| |
|
|
|
|
|
|
|
|
-------
""",
r"""
-----
| |
O |
|
|
|
|
|
|
|
-------
""",
r"""
-----
| |
O |
--- |
| |
| |
|
|
|
|
-------
""",
r"""
-----
| |
O |
--- |
/ | |
| |
|
|
|
|
-------
""",
r"""
-----
| |
O |
--- |
/ | \ |
| |
|
|
|
|
-------
""",
r"""
-----
| |
O |
--- |
/ | \ |
| |
--- |
/ |
| |
|
-------
""",
r"""
-----
| |
O |
--- |
/ | \ |
| |
--- |
/ \ |
| | |
|
-------
""",
]
print(hanged_man[wrong_guesses])
Во время игры вы отслеживаете количество неправильных догадок, которые сделал игрок, и затем передаете эти данные в функцию draw_hanged_man(), чтобы отобразить соответствующее состояние висельника с помощью символов ASCII.
Вот что представляет собой эта функция на практике:
>>> from hangman import draw_hanged_man
>>> draw_hanged_man(0)
-----
| |
|
|
|
|
|
|
|
|
-------
>>> draw_hanged_man(6)
-----
| |
O |
--- |
/ | \ |
| |
--- |
/ \ |
| | |
|
-------
Когда вы обращаетесь к функции draw_hanged_man() с целочисленным индексом в качестве аргумента, вы получаете ASCII-рисунок, отображающий текущий процесс игры в виселицу. Выглядит неплохо, не правда ли?
Шаг 6: Определение момента завершения игры
Обычно игры заканчиваются по условию, заданному игроком. Возможно, игрок наконец-то достиг поставленной цели, или же он не справился с заданием и проиграл.
Ваша игра «Виселица» закончится, когда произойдет одно из двух возможных событий:
- Игрок сделал шесть неправильных догадок.
- Игрок правильно угадывает слово.
Оба этих результата зависят от действий игрока. Поэтому логично проверять их в рамках цикла игры, в ходе которого вы собираете, проверяете и обрабатываете все введенные игроком данные. Заключение этих проверок в функцию – отличная идея.
Поскольку требуется проверить два условия, вам следует передать функции game_over() всю необходимую информацию для проверки каждого из них. Ей нужно знать количество угаданных вариаций, текущее слово и отгаданные буквы:
# hangman.py
# ...
MAX_INCORRECT_GUESSES = 6
# ...
def game_over(wrong_guesses, target_word, guessed_letters):
if wrong_guesses == MAX_INCORRECT_GUESSES:
return True
if set(target_word) <= guessed_letters:
return True
return False
Проверка количества неправильных догадок – дело простое, а вот проверка того, правильно ли игрок угадал слово, может потребовать небольшого комментария.
Встроенная функция set() превращает любой итерируемый объект в множество. Поскольку каждый элемент в массиве уникален, создается ряд, состоящий из букв, образующих слово target_word. Затем вы сравниваете это множество с letters_guessed с помощью оператора <=, который проверяет, является ли каждый элемент левого множества членом правого множества. Если это так, то игрок отгадал все буквы.
if в game_over() для удобного чтения кода. Вы также могли бы написать эту функцию следующим образом:
# hangman.py
# ...
def game_over(guesses_taken, target_word, letters_guessed):
return (
guesses_taken == MAX_INCORRECT_GUESSES
or set(target_word) <= letters_guessed
)
Оба варианта работают одинаково эффективно. Какой из них использовать – решать исключительно вам.
Теперь, когда у вас есть все ингредиенты, самое время испечь торт!
Шаг 7: Запуск цикла игры
До этого момента вы уже собрали функции и код, которые охватывают большинство важных составляющих вашей игры в виселицу. Эти элементы включают следующее:
- Выбор случайного слова для отгадывания
- Сбор и обработка вводимых игроком данных
- Отображение слова со скрытыми буквами
- Демонстрация рисунка повешенного человека
- Отслеживание угаданных букв и отгаданных слов
- Проверка готовности игры к завершению.
Последняя задача – собрать все вместе в целую игру. Вам понадобится игровой цикл, чтобы управлять процессом игры. Однако не все помещается в цикл. Перед началом запуска цикла необходимо запустить игру. После завершения цикла необходимо завершить игру.
Первоначальная настройка включает в себя обеспечение начального состояния игры. Чтобы определить начальное состояние, вам нужно выбрать слово для отгадывания, исходные буквы, загаданное слово в его текущем виде и количество неправильных предположений. После того как вы зададите эти переменные, можно пригласить игрока к участию:
# hangman.py
# ...
if __name__ == "__main__":
# Initial setup
target_word = select_word()
guessed_letters = set()
guessed_word = build_guessed_word(target_word, guessed_letters)
wrong_guesses = 0
print("Welcome to Hangman!")
Подготовив игру, вы можете начать ее цикл. Помните, что игровой цикл не завершится, пока игрок не отгадает слово или пока не закончатся предположения.
При каждом цикле необходимо выполнить определенные задачи:
- Проверить, закончилась ли игра.
- Отобразить рисунок повешенного человека.
- Показать угаданное или заданное слово.
- Вывести на экран отгаданные буквы.
- Получить от игрока предложение о букве.
- Проверить наличие введенной буквы в заданном слове.
- Обновить отображаемое слово и угаданные буквы.
Вот один из вариантов написания игрового цикла:
# hangman.py
# ...
if __name__ == "__main__":
# ...
# Game loop
while not game_over(wrong_guesses, target_word, guessed_letters):
draw_hanged_man(wrong_guesses)
print(f"Your word is: {guessed_word}")
print(
"Current guessed letters: "
f"{join_guessed_letters(guessed_letters)}\n"
)
player_guess = get_player_input(guessed_letters)
if player_guess in target_word:
print("Great guess!")
else:
print("Sorry, it's not there.")
wrong_guesses += 1
guessed_letters.add(player_guess)
guessed_word = build_guessed_word(target_word, guessed_letters)
Цикл не завершится, пока игра не закончится, поэтому для управления процессом можно использовать функцию game_over(). Внутри цикла все начинается с показа первоначального рисунка виселицы. Затем отображается заданное слово и, наконец, отгаданные буквы.
Затем вы получаете и оцениваете введенные игроком данные. В условном операторе вы проверяете, находится ли отгаданная игроком буква в заданном слове. Если это так, то выводится сообщение об успехе. В противном случае печатается сообщение о провале и счетчик wrong_guesses увеличивается на единицу.
В заключение вы добавляете текущую догадку к guessed_letters и обновляете слово при помощи функции build_guessed_word().
Когда игра закончится и игровой цикл завершится, вам останется выполнить несколько завершающих задач:
# hangman.py
# ...
if __name__ == "__main__":
# ...
# Game over
draw_hanged_man(wrong_guesses)
if wrong_guesses == MAX_INCORRECT_GUESSES:
print("Sorry, you lost!")
else:
print("Congrats! You did it!")
print(f"Your word was: {target_word}")
Во-первых, вы вызываете draw_hanged_man(), чтобы отобразить финальный рисунок повешенного. Это необходимо, потому что вы демонстрируете повешенного человека только в самом начале цикла игры. Таким образом, в последней итерации рисунок не обновляется.
В этот момент у игрока либо закончились предположения и он проиграл, либо он правильно отгадал слово и выиграл. Об этом можно узнать, проверив итоговое количество неправильных догадок и выведя соответствующее сообщение.
Теперь ваша игра «Виселица» готова к первому испытанию. Запустите игру из командной строки:
$ python hangman.py
Welcome to Hangman!
-----
| |
|
|
|
|
|
|
|
|
-------
Your word is: _ _ _ _ _
Current guessed letters:
Guess a letter: e
Sorry, it's not there.
-----
| |
O |
|
|
|
|
|
|
|
-------
Your word is: _ _ _ _ _
Current guessed letters: e
Guess a letter:
Вот это круто! Ваша игра «Виселица» работает, как и было задумано! Вы готовы к тому, чтобы использовать игру для развлечения и практических тренировок.
Получите свой код: Кликните здесь, чтобы загрузить исходный код для создания игры «Виселица» на Python.
Заключение
Создание игры «Виселица» на Python – это отличный способ развития навыков программирования, изучения новых техник и знакомства с миром компьютерных игр. Написав игру для командной строки на Python, вы приняли участие в решении нескольких задач по кодированию и дизайну, включая получение пользовательских данных, их обработку и отображение удобных для пользователя результатов.
В этом руководстве вы узнали, как:
- Создать компьютерную игру с различными элементами
- Отслеживать состояние игры
- Получать и обрабатывать вводимые пользователем данные
- Создать текстовый пользовательский интерфейс (TUI) для вашей игры
- Определить, закончилась ли игра и кто выиграл.
В следующей части мы напишем графический интерфейс для игры «Виселица».
Комментарии