def test_tah_spatny_symbol_ox():
"""Tah s více symboly najednou by měl skončit chybou ValueError"""
from util import tah
with pytest.raises(ValueError):
tah("--------------------", 2, 'xo')
with pytest.raises(ValueError):
tah("--------------------", 2, 'ox')
def test_tah_o():
"""Pozitivní test funkce `tah` se symbolem 'o'"""
from util import tah
assert tah("--------------------", 0, 'o') == 'o-------------------'
assert tah("--------------------", 10, 'o') == '----------o---------'
assert tah("--------------------", 19, 'o') == '-------------------o'
assert tah("x-xo----------------", 1, 'o') == 'xoxo----------------'
def test_tah_mala_pismena():
"""Symboly 'o' a 'x' musí být malým písmenem"""
from util import tah
with pytest.raises(ValueError):
tah("--------------------", 2, 'O')
with pytest.raises(ValueError):
tah("--------------------", 2, 'X')
def test_tah_x():
"""Pozitivní test funkce `tah` se symbolem 'x'"""
from util import tah
assert tah("--------------------", 0, 'x') == 'x-------------------'
assert tah("--------------------", 10, 'x') == '----------x---------'
assert tah("--------------------", 19, 'x') == '-------------------x'
assert tah("o-ox----------------", 1, 'x') == 'oxox----------------'
def tah_pocitace(pole, symbol_pocitace, symbol_hrace, delka_pole):
"""
Vrátí herní pole se zaznamenaným tahem počítače
"""
while True:
if delka_pole == 0:
raise ValueError('Nulove pole. To si moc nezahrajes.')
if delka_pole < 6:
raise ValueError('Na poli mensim 6 policek nejde hrat.')
if '-' not in pole:
raise ValueError('Pole je zaplneno.')
cislo_policka = randrange(0, delka_pole)
if (symbol_pocitace + '-' + symbol_pocitace) in pole:
cislo_policka = pole.index(symbol_pocitace + '-' + symbol_pocitace) + 1
print('Pocitac hraje na pozici: ', cislo_policka + 1)
return tah(pole, cislo_policka, symbol_pocitace)
elif (symbol_hrace + '-') in pole:
cislo_policka = pole.index(symbol_hrace + '-') + 1
print('Pocitac hraje na pozici: ', cislo_policka + 1)
return tah(pole, cislo_policka, symbol_pocitace)
elif ('-' + symbol_hrace) in pole:
cislo_policka = pole.index('-' + symbol_hrace)
print('Pocitac hraje na pozici: ', cislo_policka + 1)
return tah(pole, cislo_policka, symbol_pocitace)
elif ('-' * delka_pole) in pole:
cislo_policka = pole.index('---')
print('Pocitac hraje na pozici: ', cislo_policka + 1)
return tah(pole, cislo_policka, symbol_pocitace)
def test_tah_x():
"""
Pozitivní testy se symbolem "x".
"""
assert tah("--------------------", 0, "x") == "x-------------------"
assert tah("--------------------", 10, "x") == "----------x---------"
assert tah("--------------------", 19, "x") == "-------------------x"
def test_tah_o():
"""
Pozitivní testy se symbolem "o".
"""
assert tah("--------------------", 0, "o") == "o-------------------"
assert tah("--------------------", 10, "o") == "----------o---------"
assert tah("--------------------", 19, "o") == "-------------------o"
def test_tah_spatny_symbol_ox():
"""Tah s více symboly najednou by měl skončit chybou ValueError"""
from util import tah
with pytest.raises(ValueError):
tah("--------------------", 2, 'xo')
with pytest.raises(ValueError):
tah("--------------------", 2, 'ox')
def test_tah_obsazeno():
"""Tah na obsazené políčko by měl skončit chybou ValueError"""
from util import tah
with pytest.raises(ValueError):
tah("o-------------------", 0, 'o')
with pytest.raises(ValueError):
tah("----------x---------", 10, 'o')
def test_tah_mala_pismena():
"""Symboly 'o' a 'x' musí být malým písmenem"""
from util import tah
with pytest.raises(ValueError):
tah("--------------------", 2, 'O')
with pytest.raises(ValueError):
tah("--------------------", 2, 'X')
def test_tah_obsazeno():
"""Tah na obsazené políčko by měl skončit chybou ValueError"""
from util import tah
with pytest.raises(ValueError):
tah("o-------------------", 0, 'o')
with pytest.raises(ValueError):
tah("----------x---------", 10, 'o')
def test_tah_x():
"""
Pozitivní testy se symbolem "x" pole 10.
"""
assert tah("----------", 0, "x") == "x---------"
assert tah("----------", 5, "x") == "-----x----"
assert tah("----------", 9, "x") == "---------x"
assert tah("----------", 3, "x") == "---x------"
def test_tah_o():
"""
Pozitivní testy se symbolem "o" pole 10.
"""
assert tah("----------", 0, "o") == "o---------"
assert tah("----------", 5, "o") == "-----o----"
assert tah("----------", 9, "o") == "---------o"
assert tah("----------", 3, "o") == "---o------"
def tah_pocitace(pole):
# Podle strategie (funkce strategie_vitezstvi() nebo strategie_obrana()) nebo nahodne zvoli policko pocitace a umisti jej pomoci funkce tah().
while True:
if strategie_vitezstvi(pole) != "nic":
policko = strategie_vitezstvi(pole)
return util.tah(pole, policko, symbol = "o")
elif strategie_obrana(pole) != "nic":
policko = strategie_obrana(pole)
return util.tah(pole, policko, symbol = "o")
else:
policko = randrange(0,19)
if pole[policko] == "-":
return util.tah(pole, policko, symbol = "o")
def tah_pocitace(pole):
"Vrátí herní pole se zaznamenaným tahem počítače (znak 'o')"
# kontrola herni situace
if '-oo' in pole: # pocitac uz ma dva symboly vedle sebe a muze doplnit dalsi vlevo
cislo_policka = pole.find('-oo') # najdu zacatek substringu '-oo'
return util.tah(pole, cislo_policka,
'o') # doplnim symbol pocitace do hraciho pole
elif 'oo-' in pole: # pocitac uz ma dva symboly vedle sebe a muze doplnit dalsi vpravo
cislo_policka = pole.find('oo-') + 2 # najdu konec substringu 'oo-'
return util.tah(pole, cislo_policka,
'o') # doplnim symbol pocitace do hraciho pole
elif '-xx' in pole: # hrac uz ma dva symboly vedle sebe a muze doplnit dalsi vlevo -> pocitac ho zablokuje
cislo_policka = pole.find('-xx') # najdu zacatek substringu '-xx'
return util.tah(pole, cislo_policka,
'o') # doplnim symbol pocitace do hraciho pole
elif 'xx-' in pole: # hrac uz ma dva symboly vedle sebe a muze doplnit dalsi vpravo -> pocitac ho zablokuje
cislo_policka = pole.find('xx-') + 2 # najdu konec substringu 'xx-'
return util.tah(pole, cislo_policka,
'o') # doplnim symbol pocitace do hraciho pole
elif '-o' in pole: # pocitac uz ma jeden symbol a muze doplnit dalsi vlevo
cislo_policka = pole.find('-o') # najdu zacatek substringu '-o'
return util.tah(pole, cislo_policka,
'o') # doplnim symbol pocitace do hraciho pole
elif 'o-' in pole: # pocitac uz ma jeden symbol a muze doplnit dalsi vpravo
cislo_policka = pole.find('o-') + 1 # najdu konec substringu 'o-'
return util.tah(pole, cislo_policka,
'o') # doplnim symbol pocitace do hraciho pole
elif '-x' in pole: # hrac ma jeden symbol a muze doplnit dalsi vlevo -> pocitac toto misto obsadi
cislo_policka = pole.find('-x') # najdu zacatek substringu '-x'
return util.tah(pole, cislo_policka,
'o') # doplnim symbol pocitace do hraciho pole
else: # hrac ma jeden symbol a muze doplnit dalsi vlevo -> pocitac toto misto obsadi
cislo_policka = pole.find('x-') + 1 # najdu konec substringu 'x-'
return util.tah(pole, cislo_policka,
'o') # doplnim symbol pocitace do hraciho pole
def tah_pocitace(herni_pole):
"Vrátí herní pole se zaznamenaným tahem počítače"
if "o-o" in herni_pole:
policko = herni_pole.find("o-o")
herni_pole = tah(herni_pole, (policko + 1), 'o')
elif "-oo" in herni_pole:
policko = herni_pole.find("-oo")
herni_pole = tah(herni_pole, policko, 'o')
elif "oo-" in herni_pole:
policko = herni_pole.find("oo-")
herni_pole = tah(herni_pole, (policko + 2), 'o')
elif "x-x" in herni_pole:
policko = herni_pole.find("x-x")
herni_pole = tah(herni_pole, (policko + 1), 'o')
elif "-xx" in herni_pole:
policko = herni_pole.find("-xx")
herni_pole = tah(herni_pole, policko, 'o')
elif "xx-" in herni_pole:
policko = herni_pole.find("xx-")
herni_pole = tah(herni_pole, (policko + 2), 'o')
elif "-x-" in herni_pole:
policko = herni_pole.find("-x-")
herni_pole = tah(herni_pole, (policko), 'o')
else:
delka_pole = len(herni_pole)
while True:
tah_pc = random.randrange(0, delka_pole)
if herni_pole[tah_pc] == '-':
herni_pole = tah(herni_pole, tah_pc, 'o')
break
return herni_pole
def tah_pocitaca(retazec):
# Vrati herne pole so zaznamenanym tahom pocitaca
# pocitac hraje s 'o'
if len(retazec) == 0:
raise ValueError('Prázdne herné pole')
if '-' not in retazec:
raise ValueError('Plné herné pole')
symbol = 'o'
print('Hraje počítač :')
symboly = (['-oo', 0], ['o-o', 1], ['oo-', 2],
['-xx', 0], ['x-x', 1], ['xx-', 2],
['--o', 1], ['-o-', 0], ['o--', 1],
['-x', 0], ['x-', 1])
policko = -1
for s in symboly:
try:
policko = retazec.index(s[0])
except ValueError:
pass
else:
policko += s[1]
break
if policko == -1:
policko = retazec.index('-')
return util.tah(retazec, symbol, policko)
def tah_hrace(pole, symbol_hrace):
"""
dostane řetězec s herním polem, zeptá se hráče,
na kterou pozici chce hrát, a vrátí herní pole se
zaznamenaným tahem hráče. Funkce by měla odmítnout
záp**ná nebo příliš velká čísla a tahy na obsazená
políčka. Pokud uživatel zadá špatný vstup, funkce mu
vynadá a zeptá se znova.
"""
zeptej_se_znova = 1
while zeptej_se_znova == 1:
cislo_policka = int(
input(
"Zadej číslo volné pozice, na kterou chces hrát od 0 do 19."))
if cislo_policka not in [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19
]:
print(
"Tohle by nešlo, číslo políčka musí být 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 nebo 19."
)
zeptej_se_znova = 1
elif pole[cislo_policka] != "-":
print("Tohle by nešlo, políčko ", cislo_policka,
"je obsazené. Zkus to znovu.")
zeptej_se_znova = 1
else:
zeptej_se_znova = 0
return tah(pole, cislo_policka, symbol_hrace)
def tah_hraca(retazec):
# Vrati herne pole s danym symbolom umiestnenym na poziciu danu hracom
# odmietne zaporne a prilis velke cislo
# odmietne tah na obsadene policko
# hrac hraje s 'x'
velkost_pola = len(retazec)
if velkost_pola == 0:
raise ValueError('Prázdne herné pole')
if '-' not in retazec:
raise ValueError('Plné herné pole')
symbol = 'x'
while True:
try:
policko = int(
raw_input(
'Zadaj číslo políčka (0 až {0}) : '.format(velkost_pola -
1)))
except ValueError:
print('Musí to byť celé číslo od 0 po {0})!'.format(velkost_pola -
1))
else:
if policko < 0 or policko >= velkost_pola:
print('Musíš zadať číslo 0 až {0})!'.format(velkost_pola - 1))
elif retazec[policko] <> '-':
print('Políčko {0} je už obsadené!'.format(policko))
else:
break
return tah(retazec, symbol, policko)
def tah_hraca(retazec):
# Vrati herne pole s danym symbolom umiestnenym na poziciu danu hracom
# odmietne zaporne a prilis velke cislo
# odmietne tah na obsadene policko
# hrac hraje s 'x'
velkost_pola = len(retazec)
if velkost_pola == 0:
raise ValueError('Prázdne herné pole')
if '-' not in retazec:
raise ValueError('Plné herné pole')
symbol = 'x'
while True:
try:
policko = int(raw_input(
'Zadaj číslo políčka (0 až {0}) : '.format(velkost_pola - 1)))
except ValueError:
print ('Musí to byť celé číslo od 0 po {0})!'.format(
velkost_pola - 1))
else:
if policko < 0 or policko >= velkost_pola:
print ('Musíš zadať číslo 0 až {0})!'.format(velkost_pola - 1))
elif retazec[policko] <> '-':
print ('Políčko {0} je už obsadené!'.format(policko))
else:
break
return tah(retazec, symbol, policko)
def tah_hrace(pole):
"Vrátí herní pole se zaznamenaným tahem hráče"
while True:
cislo_policka = int(input('Kterou pozici od 0 do 19 si zabíráš? '))
if cislo_policka >= 0 and cislo_policka < 20 and '-' == pole[cislo_policka]:
return tah(pole, cislo_policka, 'x')
def tah_pocitace(pole, symbol):
if '-' not in pole:
raise ValueError('pole je plné')
while True:
pozice = randrange(len(pole))
if pole[pozice] == '-':
return tah(pole, pozice, symbol)
def tah_hrace(pole, symbol):
while True:
pozice = input("Na jake pozici chces hrat? Zadej 0-19")
int_pozice = int(pozice)
if int_pozice >= 0 and int_pozice <= 19 and pole[int_pozice] == "-":
return util.tah(pole, int_pozice, symbol)
else:
print("Zadal jsi spatne cislo, tytyty! Styd se!")
def tah_pc(pole):
symbol = 'O'
cislo_pole = randrange(20)
if pole[cislo_pole] == '-':
print('Pocitac zvolil toto pole')
pole = tah(pole, cislo_pole, symbol)
return pole
return tah_pc(pole)
def pozice_pocitace(pole, symbol_pocitace):
#funkce pro nahodne vlozeni symbolu pocitace na nahodnou pozici
while True: #overi, zda pocitac nechce vlozit symbol na j*z jiny vlozeny symbol
cislo_pole_pocitace = randrange(0, len(pole))
if pole[cislo_pole_pocitace] != "-":
continue
else:
return tah(pole, cislo_pole_pocitace, symbol_pocitace)
def tah_hrace(pole):
'Zapise do pole tah hrace - vrati pole se zapsanym tahem.'
symbol = 'x'
cislo = input('Zadej pozici, na kterou chces hrat: ')
while vklad(pole, cislo) != True:
cislo = input('Zadej pozici, na kterou chces hrat: ')
pozice = int(cislo)
return util.tah(pole, pozice, symbol)
def test_tah():
pole = "-" * 10
pole = util.tah(pole, 5, "o")
assert pole == "----o-----"
assert len(pole) == 10
assert pole.count("o") == 1
assert pole.count("-") == 9
assert pole[5 - 1] == "o"
def tah_hrace(pole):
while True:
cislo_policka = int(input('Zadejte pozici symbolu od 0 do 19:'))
if cislo_policka >= 0 and cislo_policka <= 19 and pole[
cislo_policka] == '-':
return tah(pole, cislo_policka, 'x')
else:
print('Špatná pozice, zadejte znovu.')
def tah_pocitace(pole, symbol):
"""Vrátí herní pole se zaznamenaným tahem počítače
`pole` je herní pole, na které se hraje.
`symbol` může být 'x' nebo 'o', podle toho jestli hráč hraje za křížky
nebo za kolečka.
Strategie: pokud má symbol v poli, pokusit se dát další symbol vedle něj
Pokud to není možné, randomly vybrat jinou pozici a umístit na ni svůj symbol
"""
if '-' not in pole:
raise ValueError("Pole je plné")
else:
if symbol not in pole:
pozice = randrange(0, 20)
while True:
if pole[pozice] == "-":
return tah(pole, pozice, symbol)
else:
pozice = randrange(0, 20)
else:
pozice = pole.index(symbol)
if pozice == 0:
if pole[pozice + 1] == "-":
return tah(pole, pozice + 1, symbol)
else:
pozice = randrange(0, 20)
while True:
if pole[pozice] == "-":
return tah(pole, pozice, symbol)
else:
pozice = randrange(0, 20)
if pozice == 19:
if pole[pozice - 1] == "-":
return tah(pole, pozice - 1, symbol)
else:
pozice = randrange(0, 20)
while True:
if pole[pozice] == "-":
return tah(pole, pozice, symbol)
else:
pozice = randrange(0, 20)
else:
if pole[pozice - 1] == "-":
return tah(pole, pozice - 1, symbol)
elif pole[pozice + 1] == "-":
return tah(pole, pozice + 1, symbol)
else:
pozice = randrange(0, 20)
while True:
if pole[pozice] == "-":
return tah(pole, pozice, symbol)
else:
pozice = randrange(0, 20)
def tah_hrace(pole):
while True:
odpoved = input("Kam hrat? ")
try:
pozice = vyhodnot_odpoved_hrace(pole, odpoved)
except ValueError as e:
print(e)
else:
return tah(pole, pozice, "o")
def tah_pocitace(pole, symbol):
delka = len(pole)
while True:
try:
index = randrange(0, delka)
return tah(pole, index, symbol)
except ValueError:
pass
def tah_pocitace(pole):
"Vrátí herní pole se zaznamenaným tahem počítače"
seznam = najdi_pozice(pole, 'x')
for cislo_policka in seznam:
if (cislo_policka == 0) and (pole[cislo_policka + 1] == '-'):
return util.tah(pole, cislo_policka + 1, 'o')
elif (cislo_policka == 19) and (pole[cislo_policka - 1] == '-'):
return util.tah(pole, cislo_policka - 1, 'o')
elif (cislo_policka > 0) and (cislo_policka < 19):
if (pole[cislo_policka + 1] == '-'):
return util.tah(pole, cislo_policka + 1, 'o')
elif (pole[cislo_policka - 1] == '-'):
return util.tah(pole, cislo_policka - 1, 'o')
while True:
cislo_policka = randrange(20)
if '-' in pole[cislo_policka]:
return util.tah(pole, cislo_policka, 'o')
def strategie_obrana(pole, symbol_pocitace, symbol_hrace):
#pocitac brani hraci zapsat tri symboly vedle sebe
obrana = pole.find("-" + "-" + symbol_hrace)
if obrana != -1:
return tah(pole, obrana + 1, symbol_pocitace)
obrana = pole.find(symbol_hrace + "-" + "-")
if obrana != -1:
return tah(pole, obrana + 1, symbol_pocitace)
obrana = pole.find(symbol_hrace + symbol_hrace + "-")
if obrana != -1:
return tah(pole, obrana + 2, symbol_pocitace)
obrana = pole.find("-" + symbol_hrace + symbol_hrace)
if obrana != -1:
return tah(pole, obrana, symbol_pocitace)
obrana = pole.find(symbol_hrace + "-" + symbol_hrace)
if obrana != -1:
return tah(pole, obrana + 1, symbol_pocitace)
if obrana == -1: #nenajde jinou moznost, naprd x_o , o_x, -> vrati nahodnou volnou pozici
return pozice_pocitace(pole, symbol_pocitace)
def tah_hrace(pole):
symbol = 'x'
while True:
cislo_policka = int(input('Na kterou pozici chces hrat? '))
if cislo_policka < 0 or cislo_policka > 19:
print('zadal jsi spatnou pozici')
elif pole[cislo_policka] != '-':
print('Policko je obsazene')
else:
return util.tah(pole, cislo_policka, symbol)
def test_tah_spatny_symbol():
"""Tah s jiným symbolem než 'o' a 'x' by měl skončit chybou ValueError"""
from util import tah
with pytest.raises(ValueError):
tah("--------------------", 2, 'řeřicha')
with pytest.raises(ValueError):
tah("--------------------", 2, 'm')
with pytest.raises(ValueError):
tah("--------------------", 2, '')
def tah_hrace(pole, znakHrac):
if "" == pole:
return pole
while True:
try:
pozice = int(input('Zadejte èíslo políèka: '))
except TypeError:
print("Chyba vstupu. Opakujte.")
except ValueError:
print("Chyba vstupu. Opakujte.")
else:
if pozice > len(pole):
print("Èíslo políèka nesmí pøekroèit {0}".format(len(pole)))
elif pozice < 0:
print("Èíslo políèka musí být kladné")
elif "o" == pole[pozice] or "x" == pole[pozice]:
#kontrola obsazenosti pole
print("Toto políèko je již obsazeno")
continue
else:
return tah(pole, pozice, znakHrac)
def test_tah_o():
"""Pozitivní test funkce `tah` se symbolem 'o'"""
from util import tah
assert tah("--------------------", 0, 'o') == 'o-------------------'
assert tah("--------------------", 10, 'o') == '----------o---------'
assert tah("--------------------", 19, 'o') == '-------------------o'
def test_tah_velka_pozice():
"""Tah na pozici co není v poli by měl skončit chybou ValueError"""
from util import tah
with pytest.raises(ValueError):
tah("--------------------", 20, 'x')
def test_tah_zaporna_pozice():
"""Tah na zápornou pozici by měl skončit chybou ValueError"""
from util import tah
with pytest.raises(ValueError):
tah("--------------------", -1, 'x')
def test_tah_x():
"""Pozitivní test funkce `tah` se symbolem 'x'"""
from util import tah
assert tah("--------------------", 0, 'x') == 'x-------------------'
assert tah("--------------------", 10, 'x') == '----------x---------'
assert tah("--------------------", 19, 'x') == '-------------------x'
def tah_pocitace(pole, symbol):
symbolPC = symbol
if "x" == symbolPC:
symbolHrace = "o"
else:
symbolHrace = "x"
#Vyherni tah pocitace
if(symbolPC*2+"-" in pole):
pozice = pole.index(symbolPC*2+"-") + 2
elif(symbolPC+"-"+symbolPC in pole):
pozice = pole.index(symbolPC+"-"+symbolPC) + 1
elif("-"+symbolPC*2 in pole):
pozice = pole.index("-"+symbolPC*2)
#obrana proti okamzitemu vitezstvi
elif(symbolHrace*2 + "-" in pole):
pozice = pole.index(symbolHrace*2 + "-") + 2
elif(symbolHrace + "-" + symbolHrace in pole):
pozice = pole.index(symbolHrace + "-" + symbolHrace) +1
elif("-" + symbolHrace*2 in pole):
pozice = pole.index("-" + symbolHrace*2)
#utocny tah
elif("-" + symbolPC + "-" in pole):
if re.search("-" + symbolPC + "-+"+symbolPC, pole):
pozice = pole.index("-" + symbolPC + "-") + 2
elif re.search(symbolPC + "-+" + symbolPC + "-", pole):
pozice = pole.index("-" + symbolPC + "-")
else:
pozice = pole.index("-" + symbolPC + "-") + randrange(0,4,2)
#utocny tah
elif(symbolPC + "---" + symbolPC in pole):
pozice = pole.index(symbolPC + "---" + symbolPC) + 2
#blokace protihrace
elif("-" + symbolHrace + "-" in pole):
if re.search("-"+ symbolHrace + "-+" + symbolHrace, pole):
pozice = pole.index("-" + symbolHrace + "-") + 2
elif re.search(symbolHrace + "-+" + symbolHrace + "-", pole):
pozice = pole.index("-" + symbolHrace + "-")
else:
pozice = pole.index("-" + symbolHrace + "-") + randrange(0,4,2)
#zaloz utok
elif(symbolPC + "----" in pole):
pozice = pole.index(symbolPC + "----") + 4
elif("----" + symbolPC in pole):
pozice = pole.index("----" + symbolPC)
#nahodna strategie, selhaly ostatni
else:
while True:
if "-" not in pole:
print("Pocitac nemuze na pole hrat")
return pole
pozice = randrange(0, len(pole))
if ("-"*len(pole) == pole) and ((pozice == 0) or (pozice == len(pole)-1)):
#je-li pole jeste prazdne, nehraj na krajni policka
continue
if "-" == pole[pozice]:
break
return tah(pole, pozice, symbolPC)
