def test_tah_pocitace_prazdne_pole():
try:
tah_pocitace('', 'x')
except Exception:
pass
else:
assert False
def test_tah_pocitace_pole_ruzne_delky():
"""
Hra na pole ruzne delky.
"""
# pole = ""
# with pytest.raises(ValueError):
# tah_pocitace(pole, "o", "x", 0)
# pole = "-"
# with pytest.raises(ValueError):
# tah_pocitace(pole, "o", "x", 1)
# pole = "---"
# with pytest.raises(ValueError):
# tah_pocitace(pole, "o", "x", 3)
for i in range(6):
pole = i * "-"
with pytest.raises(ValueError):
tah_pocitace(pole, "o", "x", i)
for i in range(6, 50):
pole = i * "-"
result = tah_pocitace(pole, "o", "x", i)
assert len(result) == i
assert result.count("o") == 1
assert result.count("-") == i - 1
def test_tah_PC_na_pole_delky_0():
'''
Test funkce tah_pocitace: funkce vyvolá vyjímku ValueError,
pokud dostane pole s délkou 0.
'''
with pytest.raises(ValueError):
ai.tah_pocitace('', 'x')
def test_tah_pocitace_plne_pole():
try:
tah_pocitace('xoxoooxoxo', 'x')
except Exception:
pass
else:
assert False
def test_tah_pocitace_plne_pole():
"""
Hra na plne pole.
"""
pole = "xoxoxoxoxoxoxoxoxoxo"
with pytest.raises(ValueError):
tah_pocitace(pole, "o", "x", 20)
def test_tah_PC_nespravny_symbol():
'''
Test funkce tah_pocitace: funkce vyvolá vyjímku ValueError,
pokud dostane jako symbol_hrac něco jiného než "x" nebo "o".
'''
for symbol_hrac in 'aBXO10-_*.':
with pytest.raises(ValueError):
ai.tah_pocitace('----------', symbol_hrac)
def test_tah_pocitace_prasit_1():
akce = tah_pocitace("--------o--------x--", "x")
assert akce == "--------o--------xx-"
akce = tah_pocitace("--------o--------xo-", "x")
assert akce == "--------ox-------xo-"
akce = tah_pocitace("--xoo---o--------xo-", "x")
assert akce == "--xoox--o--------xo-"
def test_tah_pocitace_branit_hasit1():
akce = tah_pocitace("-oo-oxoxoxoxxoxoxxoo", "x")
assert akce == "xoo-oxoxoxoxxoxoxxoo"
akce = tah_pocitace("oxxo-------------o-o", "x")
assert akce == "oxxo-------------oxo"
akce = tah_pocitace("oo--oxoxoxoxxoxoxxoo", "x")
assert akce == "oox-oxoxoxoxxoxoxxoo"
def test_tah_pocitace_dlouhy():
akce = tah_pocitace("-------------------------------", "o")
vysledek_akce = "o" in akce
assert vysledek_akce == True
akce = tah_pocitace("----------------------xx", "x")
assert akce == "---------------------xxx"
akce = tah_pocitace("oxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxxox-", "o")
assert akce == "oxoxoxoxoxoxoxoxoxoxoxoxoxoxoxoxxoxo"
def test_musi_vyhrat():
pole = ai.tah_pocitace('o-xx--------------o-', 'x', 'o')
assert pole[1] == 'x' or pole[4] == 'x'
assert ai.tah_pocitace('o-x-x-------------o-', 'x', 'o').find('xxx') == 2
for pole in (
'o-x--x-----x-x----o-',
'o-xx--------------o-',
'o-x-x-x--x-x---xx-----o-',
'o-ox-x-----x-x----o-',
):
assert ai.tah_pocitace(pole, 'x', 'o').find('xxx') != -1
def test_tah_pocitace_vyhravat():
akce = tah_pocitace("-xx-----xx-------oxo", "x")
assert akce == "xxx-----xx-------oxo"
akce = tah_pocitace("oxxo---x-x--------oo", "x")
assert akce == "oxxo---xxx--------oo"
akce = tah_pocitace("oxx--------------o-o", "x")
assert akce == "oxxx-------------o-o"
akce = tah_pocitace("oxx--------------o-o", "o")
assert akce == "oxx--------------ooo"
def test_tah_pocitace_skoro_plne_zacatek():
"""Tah počítače na skoro plné pole (volno na začátku)"""
from ai import tah_pocitace
pole = '-xoxoxoxoxoxoxoxoxox'
result = tah_pocitace(pole, 'o')
# Je jen 1 možnost kam hrát.
assert result == 'oxoxoxoxoxoxoxoxoxox'
def piskvorky1d():
prubeh_hry = '--------------------' # aktualni herni pole, defaultni hodnota je prazdne pole
cislo_tahu = 1 # defaultni cislo tahu
vysledek = '-' # defaultni vysledek
while vysledek == '-': # dokud hra neskoncila, cyklus pokracuje
if cislo_tahu % 2 == 1: # hru zacina hrac
prubeh_hry = tah_hrace(prubeh_hry) #pridame tah hrace
print("Hráč:", prubeh_hry)
else: # pokracuje pocitac
prubeh_hry = ai.tah_pocitace(
prubeh_hry) # do listu pridame tah pocitace
print("Počítač:", prubeh_hry)
vysledek = vyhodnot(prubeh_hry) # vyhodnoti vysledek
# pokud hra skoncila, vypise vysledek a posledni hrane pole, jinak zvysi cislo tahu a cyklus pookracuje
if vysledek == '-':
cislo_tahu += 1
continue
elif vysledek == 'x':
print("Vyhral hrac!", prubeh_hry)
break
elif vysledek == 'o':
print("Vyhral pocitac!", prubeh_hry)
break
elif vysledek == '!':
print("Remiza", prubeh_hry)
break
def piskvorky1d():
pole = "-" * 20
znak_hrace = "o"
znak_pocitace = "x"
symbol = znak_pocitace
print("Hráč má ", znak_hrace)
print("Počítač má", znak_pocitace)
print(pole)
while True:
pole = tah_hrace(pole)
pole = tah_pocitace(pole, symbol)
vysledek = vyhodnot(pole)
if vysledek != "-": # už není volné pole
if vysledek == "o":
print("Vyhral jsi.")
elif vysledek == "x":
print("Vyhrál počítač.")
elif vysledek == "!":
print("Remíza.")
break
print(pole)
def piskvorky1d():
DELKA_POLE = 10
if DELKA_POLE < 5:
raise ValueError('Číslo hracího pole musí být větší nebo rovno 5')
pole = DELKA_POLE * "-"
while True:
print(pole)
pole = tah_hrace(pole, "x")
print(pole)
if vyhodnot(pole) != "-":
break
pole = tah_pocitace(pole, "o")
if vyhodnot(pole) != "-":
break
pass
"""
Hraje 1D piškvorky.
"""
pass
if vyhodnot(pole) == "x":
print("Vyhrál člověk")
elif vyhodnot(pole) == "o":
print("Vyhrál počítač")
elif vyhodnot(pole) == "!":
print("Remíza")
def piskvorky1d():
delka_pole = 10
if delka_pole <= 0:
print('Delka pole je < 0. Hra nemuze zacit.')
exit()
retezec = '-' * delka_pole
symbol_pocitace = 'o'
symbol_hrac = 'x'
print(retezec)
while True:
retezec = tah_hrace(retezec, symbol_hrac)
print(retezec)
vyhodnot(retezec)
retezec = tah_pocitace(retezec, symbol_pocitace)
print('PC zahral:')
print(retezec)
vyhodnot(retezec)
#piskvorky1d()
def test_long(ai):
"""Hra na dlouhé pole"""
for symbol in "ox":
result = ai.tah_pocitace("-" * 100, symbol)
assert len(result) == 100
assert result.count("-") == 99
assert result.count(symbol) == 1
def test_tah_pocitace_skoro_plne():
"""Tah počítače na skoro plné pole (volno uprostřed)"""
from ai import tah_pocitace
pole = 'xoxoxoxoxo-xoxoxoxox'
result = tah_pocitace(pole, 'o')
# Je jen 1 možnost kam hrát.
assert result == 'xoxoxoxoxooxoxoxoxox'
def test_empty(ai):
"""Hra na prázdné pole"""
for symbol in "ox":
result = ai.tah_pocitace("-" * 20, symbol)
assert len(result) == 20
assert result.count("-") == 19
assert result.count(symbol) == 1
def test_tah_pocitace_skoro_plne_konec():
"""Tah počítače na skoro plné pole (volno na konci)"""
from ai import tah_pocitace
pole = 'oxoxoxoxoxoxoxoxoxo-'
result = tah_pocitace(pole, 'x')
# Je jen 1 možnost kam hrát.
assert result == 'oxoxoxoxoxoxoxoxoxox'
def test_short(ai):
"""Hra na krátké pole"""
for symbol in "ox":
result = ai.tah_pocitace("-" * 5, symbol)
assert len(result) == 5
assert result.count("-") == 4
assert result.count(symbol) == 1
def test_almost_full(ai):
"""Hra na skoro plné pole (volno uprostřed)"""
pole = "xoxoxoxoxo-xoxoxoxox"
result = ai.tah_pocitace(pole, "o")
assert len(result) == 20
assert result.count("x") == 10
assert result.count("o") == 10
def piskvorky1d(velikost, symbol_hrace):
"Funkce volá tah hráče a tah počítače, dokud hra neskončí výhrou nebo remízou."
akt_pole = velikost * "-"
hra = vyhodnot(akt_pole)
while hra == "-": # ani vítězství, ani remíza
akt_pole = tah_hrace(akt_pole, symbol_hrace)
hra = vyhodnot(akt_pole)
if hra != "-":
break
print("Pole vypadá takto:", akt_pole, end="\n")
print("\nHraje počítač.\n")
akt_pole, symbol_pocitace = tah_pocitace(akt_pole, symbol_hrace)
print("Pole vypadá takto:", akt_pole, end="\n")
hra = vyhodnot(akt_pole)
print()
if hra == symbol_hrace:
print("Pole vypadá takto:", akt_pole, end="\n")
vysledek = "Gratuluji! Vyhrál jsi!\n"
elif hra == symbol_pocitace:
vysledek = "Je mi líto. Vyhrál počítač.\n"
elif hra == "!":
vysledek = "Remíza.\n"
print(vysledek)
return vysledek
def test_almost_full(ai):
"""Hra na skoro plné pole (volno uprostřed)"""
pole = 'xoxoxoxoxo-xoxoxoxox'
result = ai.tah_pocitace(pole, 'o')
assert len(result) == 20
assert result.count('x') == 10
assert result.count('o') == 10
def test_almost_full_beginning(ai):
"""Hra na skoro plné pole (volno na začátku)"""
pole = '-xoxoxoxoxoxoxoxoxox'
result = ai.tah_pocitace(pole, 'o')
assert len(result) == 20
assert result.count('x') == 10
assert result.count('o') == 10
def test_short(ai):
"""Hra na krátké pole"""
for symbol in 'ox':
result = ai.tah_pocitace('-' * 5, symbol)
assert len(result) == 5
assert result.count('-') == 4
assert result.count(symbol) == 1
def test_long(ai):
"""Hra na dlouhé pole"""
for symbol in 'ox':
result = ai.tah_pocitace('-' * 100, symbol)
assert len(result) == 100
assert result.count('-') == 99
assert result.count(symbol) == 1
def test_empty(ai):
"""Hra na prázdné pole"""
for symbol in 'ox':
result = ai.tah_pocitace('-' * 20, symbol)
assert len(result) == 20
assert result.count('-') == 19
assert result.count(symbol) == 1
def test_almost_full_end(ai):
"""Hra na skoro plné pole (2× volno na konci)"""
pole = "xooxxooxoxoxoxooxx--"
result = ai.tah_pocitace(pole, "x")
assert len(result) == 20
assert result.count("x") == 10
assert result.count("o") == 9
def test_almost_full_beginning(ai):
"""Hra na skoro plné pole (volno na začátku)"""
pole = "-xoxoxoxoxoxoxoxoxox"
result = ai.tah_pocitace(pole, "o")
assert len(result) == 20
assert result.count("x") == 10
assert result.count("o") == 10
def test_almost_full_end2(ai):
"""Hra na skoro plné pole (2× volno na konci)"""
pole = 'xooxxooxoxoxoxooxx--'
result = ai.tah_pocitace(pole, 'x')
assert len(result) == 20
assert result.count('x') == 10
assert result.count('o') == 9
def piskvorky1d():
"""
Hraje 1D piškvorky.
"""
delka_pole = 21
symbol_hrace = 'x'
symbol_pocitace = 'o'
pole = delka_pole * '-'
stav_hry = '-'
hraje_pocitac = False
while stav_hry == '-':
if hraje_pocitac:
pole = tah_pocitace(pole, symbol_pocitace, symbol_hrace,
delka_pole)
else:
pole = tah_hrace(pole, symbol_hrace, delka_pole)
print(pole)
stav_hry = vyhodnot(pole, symbol_hrace, symbol_pocitace)
hraje_pocitac = not hraje_pocitac
if stav_hry == symbol_hrace:
print('Vyhral jsi!')
elif stav_hry == symbol_pocitace:
print('Vyhral pocitac!')
elif stav_hry == '!':
print('Remiza')
return symbol_hrace, symbol_pocitace, delka_pole
def test_almost_full_beginning(ai):
"""Hra na skoro plné pole (volno na začátku)"""
pole = '-xoxoxoxoxoxoxoxoxox'
result = ai.tah_pocitace(pole, 'o')
assert len(result) == 20, result + ': Špatná délka pole'
assert result.count('x') == 10, result + ': Špatný počet symbolů x'
assert result.count('o') == 10, result + ': Špatný počet symbolů o'
def piskvorky1D():
pole = "-" * 20
# kdo ma jaky znak 0:PC-x a hrac-o, 1:PC-o a hrac-x
if randrange(0, 2):
znakPC = "x"
znakHrac = "o"
else:
znakPC = "o"
znakHrac = "x"
print("Hrac ma", znakHrac)
while True:
pole = tah_pocitace(pole, znakPC)
print(pole)
if "-" != vyhodnot(pole, znakHrac, znakPC):
# j*z neni volne pole
break
pole = tah_hrace(pole, znakHrac)
print(pole)
if "-" != vyhodnot(pole, znakHrac, znakPC):
# j*z neni volne pole
break
if "o" == vyhodnot(pole, znakHrac, znakPC):
print("Vyhral hrac s kolecky")
elif "x" == vyhodnot(pole, znakHrac, znakPC):
print("Vyhral hrac s krizky")
else:
print("Remiza")
def main():
global vyhra
global pole
while vyhra == '-':
policko = int(input('Na které políčko chceš hrát? (0-19)'))
pole = tah_hrace(pole, policko)
print(pole)
print('teď hraje počítač')
pole = tah_pocitace(pole)
print(pole)
vyhra = vyhodnot_stav(pole)
print(vyhra)
vyhra = vyhodnot_stav(pole)
if vyhra == '!':
print('Remíza')
elif vyhra == 'x':
print('Vyhrál jsi!')
elif vyhra == 'o':
print('Vyhrál počítač!')
else:
print('Máš kód na houby a koukej si tam najít chybu'
) # kontrolní řádka pro mě
def test_almost_full_end(ai):
"""Hra na skoro plné pole (2× volno na konci)"""
pole = 'xooxxooxoxoxoxooxx--'
result = ai.tah_pocitace(pole, 'x')
assert len(result) == 20, result + ': Špatná délka pole'
assert result.count('x') == 10, result + ': Špatný počet symbolů x'
assert result.count('o') == 9, result + ': Špatný počet symbolů o'
def test_tah_pocitace_prazdne():
"""Tah počítače na prázdné pole"""
from ai import tah_pocitace
for symbol in 'ox':
result = tah_pocitace('-' * 20, symbol)
assert len(result) == 20, result + ': Špatná délka pole'
assert result.count('-') == 19, result + ': Špatný počet pomlček'
assert result.count(symbol) == 1, result + ': Špatný počet symbolů ' + symbol
def test_tah_pocitace_skoro_plne_zacatek():
"""Tah počítače na skoro plné pole (volno na začátku)"""
from ai import tah_pocitace
pole = '-xoxoxoxoxoxoxoxoxox'
result = tah_pocitace(pole, 'o')
assert len(result) == 20, result + ': Špatná délka pole'
assert result.count('x') == 10, result + ': Špatný počet symbolů x'
assert result.count('o') == 10, result + ': Špatný počet symbolů o'
def test_tah_pocitace_skoro_plne_konec2():
"""Tah počítače na skoro plné pole (2× volno na konci)"""
from ai import tah_pocitace
pole = 'xooxxooxoxoxoxooxx--'
result = tah_pocitace(pole, 'x')
assert len(result) == 20, result + ': Špatná délka pole'
assert result.count('x') == 10, result + ': Špatný počet symbolů x'
assert result.count('o') == 9, result + ': Špatný počet symbolů o'
def piskvorky1d(turn, game_table, user_char, pc_char):
while not piskvorky.evaluate(game_table, user_char, pc_char, free_positions):
if starting_user:
game_table = piskvorky.man_turn(game_table, game_table_char, user_char, free_positions)
game_table = tah_pocitace(game_table, game_table_char, pc_char, user_char, free_positions, hardness)
print('{}. kolo: {} | {}'.format(turn, game_table, game_table.count(pc_char)))
else:
game_table = tah_pocitace(game_table, game_table_char, pc_char, user_char, free_positions, hardness)
print('{}. kolo: {} | {}'.format(turn, game_table, game_table.count(pc_char)))
if piskvorky.evaluate(game_table, user_char, pc_char, free_positions):
break
game_table = piskvorky.man_turn(game_table, game_table_char, user_char, free_positions)
turn = turn + 1
if piskvorky.evaluate(game_table, user_char, pc_char, free_positions) == user_char:
print('Vyhrals')
elif piskvorky.evaluate(game_table, user_char, pc_char, free_positions) == pc_char:
print('Pocitac vyhral')
else:
print('Remiza, uz neni kam hrat')
def piskvorky1D():
pole = "-" * 20
while "-" == vyhodnot(pole):
pole = tah_hrace(pole)
print(pole)
pole = tah_pocitace(pole)
print(pole)
if "o"== vyhodnot(pole):
print("Vyhral hrac")
elif "x" == vyhodnot(pole):
print("Vyhral pocitac")
else:
print("Remiza")
def piskvorky1d(pole):
while True: # velmi častý případ použití while, prostě dokud podmínka bude platit!
print("POLE:", pole)
pole = tah_hrace(pole)
vysledek = vyhodnot(pole)
if vysledek == "x":
print("Výsledný stav:", pole)
print("Vyhrál jsi!")
break
elif vysledek == "o":
print("Výsledný stav:", pole)
print("Počítač vyhrál")
break
pole = ai.tah_pocitace(pole)
vysledek = vyhodnot(pole)
if vysledek == "x":
print("vyhrál jsi!")
break
elif vysledek == "o":
print("Počítač vyhrál")
break
def test_zero(ai):
"""Hra na pole nulové délky"""
for symbol in "ox":
with pytest.raises(rozumne_vyjimky):
result = ai.tah_pocitace("", symbol)
def test_tah_pocitace_plne():
"""Tah počítače na plné pole musí vyvolat výjimku"""
from ai import tah_pocitace
for symbol in 'ox':
with pytest.raises(ValueError):
result = tah_pocitace('x' * 20, symbol)
def test_ai():
assert tah_pocitace("","x") == ""
assert tah_pocitace("---", "x") == "---"
def test_tah():
pole = ai.tah_pocitace('--------------------')
assert len(pole) == 20
assert pole.count('o') == 1
assert pole.count('-') == 19
def test_tah_chyba():
with pytest.raises(ValueError):
ai.tah_pocitace('oxoxoxoxoxoxoxoxoxox')
def test_full(ai):
"""Hra na plné pole"""
for symbol in "ox":
with pytest.raises(rozumne_vyjimky):
result = ai.tah_pocitace("x" * 20, symbol)
