Piškvorky

Dva hráči, X a O, pět v řadě na mřížce 15 × 15; šipky a mezerník. Učí seznam jako mřížku, funkce s návratem a hledání v řadě.

Otevřít v Tokbitu Úroveň: Expert. Zdarma v prohlížeči, bez instalace a bez účtu.

V Tokbitu příklad spusť a krokuj: před každým krokem si řekni, co se stane, a v panelu Proměnné to ověř. Pak ho uprav podle sebe.

Vývojový diagram

Vývojový diagram příkladu Piškvorky

Program v Pythonu

Stejný program jako kód v Pythonu. V Tokbitu ho uvidíš, když nad diagramem přepneš na Python.

"""Piškvorky pro dva: pět v řadě na mřížce 15 × 15. Učí seznam jako hrací plochu."""
# Funkce obrazovky Tokbitu, v běžném Pythonu nejsou:
from tokbit import (
    cls, at, color, background, border, key, sleep, beep, note, BLACK, WHITE,
    CYAN, BLUE, YELLOW, LIGHT_RED, GREY, LIGHT_GREEN,
)

def smer(pole: list[str], x: int, y: int, dx: int, dy: int) -> int:
    """Počítá stejné kameny jedním směrem dx, dy, dokud řada nepřeruší."""
    znak: str = pole[y * 15 + x]
    n: int = 0
    x = x + dx
    y = y + dy
    while x >= 0 and x < 15 and y >= 0 and y < 15 and pole[y * 15 + x] == znak:
        n = n + 1
        x = x + dx
        y = y + dy
    return n

def kresli_mrizku():
    """Nadpis a prázdná mřížka 15 × 15 z teček."""
    background(BLACK)
    border(BLUE)
    cls()
    color(WHITE)
    at(0, 0)
    print("PIŠKVORKY: šipky a mezerník, pět v řadě", end="")
    color(GREY)
    for y in range(15):
        at(4, 2 + y)
        print(" ." * 15, end="")

def prazdne_pole() -> list[str]:
    """Hrací plocha jako seznam 225 polí (řádky po 15), na začátku samé tečky."""
    pole: list[str] = []
    for i in range(225):
        pole.append(".")
    return pole

def ukaz_kurzor(cx: int, cy: int, hrac: str):
    """Šipka > u vybraného pole a kdo je na tahu."""
    color(WHITE)
    at(4 + 2 * cx, 2 + cy)
    print(">", end="")
    at(2, 18)
    print("Na tahu: " + hrac, end="")

def posun_kurzor(k: str, c: int, minus: str, plus: str) -> int:
    """Nová souřadnice kurzoru: klávesa minus ubere, plus přidá, jen uvnitř mřížky."""
    if k == minus and c > 0:
        return c - 1
    if k == plus and c < 14:
        return c + 1
    return c

def kresli_kamen(hrac: str, cx: int, cy: int):
    """Kámen X žlutě, O tyrkysově, každý se svým tónem."""
    if hrac == "X":
        color(YELLOW)
        beep(660, 30)
    else:
        color(CYAN)
        beep(440, 30)
    at(5 + 2 * (cx), 2 + (cy))
    print(hrac, end="")

def hlaska(text: str, barva: int):
    """Hláška pod mřížkou v dané barvě."""
    color(barva)
    at(2, 20)
    print(text, end="")

def smer_vyhry(pole: list[str], x: int, y: int, dxs: list[int], dys: list[int]) -> int:
    """Ve kterém ze čtyř směrů je přes pole x, y pět v řadě (0–3), nebo -1."""
    for d in range(4):
        if 1 + smer(pole, x, y, dxs[d], dys[d]) + smer(pole, x, y, -dxs[d], -dys[d]) >= 5:
            return d
    return -1

def zvyrazni_petici(pole: list[str], x: int, y: int, dx: int, dy: int, vitez: str):
    """Přebarví vítěznou pětici zeleně, od jejího začátku ve směru dx, dy."""
    sx: int = x - dx * smer(pole, x, y, -dx, -dy)
    sy: int = y - dy * smer(pole, x, y, -dx, -dy)
    color(LIGHT_GREEN)
    for j in range(5):
        at(5 + 2 * (sx + j * dx), 2 + sy + j * dy)
        print(vitez, end="")

def fanfara():
    """Krátká vítězná melodie."""
    note("C5", 120)
    note("E5", 120)
    note("G5", 120)
    note("C6", 300)

hrat: str = "a"
while True:
    kresli_mrizku()
    pole: list[str] = prazdne_pole()
    dxs: list[int] = [1, 0, 1, 1]
    dys: list[int] = [0, 1, 1, -1]
    cx: int = 7
    cy: int = 7
    hrac: str = "X"
    k: str = ""
    tahy: int = 0
    konec: bool = False
    vitez: str = ""
    wdx: int = 0
    wdy: int = 0
    # Herní smyčka: tah hráče, kontrola pěti v řadě, střídání hráčů.
    while not konec:
        ukaz_kurzor(cx, cy, hrac)
        sleep(30)
        k = key()
        if k == "left" or k == "right" or k == "up" or k == "down":
            at(4 + 2 * cx, 2 + cy)
            print(" ", end="")
            cx = posun_kurzor(k, cx, "left", "right")
            cy = posun_kurzor(k, cy, "up", "down")
        if k == " ":
            i: int = cy * 15 + cx
            if pole[i] != ".":
                hlaska("Tohle pole je obsazené.", LIGHT_RED)
                beep(110, 80)
            else:
                pole[i] = hrac
                kresli_kamen(hrac, cx, cy)
                tahy = tahy + 1
                at(2, 20)
                print(" " * 30, end="")
                vyhra: int = smer_vyhry(pole, cx, cy, dxs, dys)
                if vyhra >= 0:
                    vitez = hrac
                    wdx = dxs[vyhra]
                    wdy = dys[vyhra]
                if vitez != "" or tahy == 225:
                    konec = True
                else:
                    if hrac == "X":
                        hrac = "O"
                    else:
                        hrac = "X"
    at(2, 18)
    print(" " * 30, end="")
    if vitez != "":
        zvyrazni_petici(pole, cx, cy, wdx, wdy, vitez)
        fanfara()
        hlaska("Vyhrál " + vitez + "!", WHITE)
    else:
        hlaska("Remíza, mřížka je plná.", WHITE)
    at(2, 22)
    hrat = input("Nová hra (a/n)?")
    if not (hrat == "a" or hrat == "y"):
        break

Všechny příklady