Debug Labs są typowe błędy „Węża”

screen = turtle.Screen()
screen.title(„Wąż”)
# tracer(0) nie wywołano

screen = turtle.Screen()
screen.title(„Wąż”)
screen.tracer(0)

def render(self):
    self.head.goto(*self.state.snake[0])
    # ...pozostałe renderowanie...
    # self.screen.update() nie wywołany

def render(self):
    self.head.goto(*self.state.snake[0])
    # ...pozostałe renderowanie...
    self.screen.update()

while igrovoj_shag():
    screen.update()
    time.sleep(ZADERZHKA_SEK)   # stała latencja
# pętla decyduje, kiedy dokładnie sprawdzić zdarzenia — pauzę, prędkość
# i restart musi być ręcznie wpleciony w jego ciało

def game_tick(self):
    if self.state.status is not GameStatus.RUNNING:
        return
    # ...
    self.screen.ontimer(self.game_tick, self.state.delay_ms)

def game_tick(self):
    # ...
    time.sleep(self.state.delay_ms / 1000)
    self.game_tick()

def game_tick(self):
    # ...
    self.screen.ontimer(self.game_tick, self.state.delay_ms)

def request_direction(self, direction):
    self.state.next_direction = direction   # bez weryfikacji!

def request_direction(self, direction):
    if is_reverse(self.state.direction, direction):
        return
    self.state.next_direction = direction

def request_direction(self, direction):
    if is_reverse(self.state.next_direction, direction):   # kontra next_direction!
        return
    self.state.next_direction = direction

def request_direction(self, direction):
    if is_reverse(self.state.direction, direction):
        return
    self.state.next_direction = direction

def choose_food(snake, rng, *, half=280):
    x = rng.randint(-half, half)   # dowolna liczba całkowita, a nie wielokrotność STEP!
    y = rng.randint(-half, half)
    return (x, y)

def choose_food(snake, rng, *, half=280, step=20):
    free = tuple(c for c in all_cells(half=half, step=step) if c not in set(snake))
    return rng.choice(free)

def choose_food(snake, rng, *, half=280, step=20):
    coords = range(-half, half + 1, step)
    return (rng.choice(coords), rng.choice(coords))   # nie sprawdza, snake!

def choose_food(snake, rng, *, half=280, step=20):
    occupied = set(snake)
    free = tuple(c for c in all_cells(half=half, step=step) if c not in occupied)
    return rng.choice(free)

def dvigat_telo():
    for indeks in range(len(segmenty) - 1):   #wrong kierunek jazdy na rowerze!
        segmenty[indeks].goto(segmenty[indeks + 1].xcor(), segmenty[indeks + 1].ycor())

def dvigat_telo():
    for indeks in range(len(segmenty) - 1, 0, -1):
        segmenty[indeks].goto(segmenty[indeks - 1].xcor(), segmenty[indeks - 1].ycor())

def obnovit_tablo():
    tablo.write(f"Wynik: {{schet}}", align="center", font=("Arial", 16, "normal"))
    #tablo.clear() nie wywołane

def obnovit_tablo():
    tablo.clear()
    tablo.write(f"Wynik: {{schet}}", align="center", font=("Arial", 16, "normal"))

def is_wall_collision(head, *, half=280):
    x, y = head
    return abs(x) >= half or abs(y) >= half   #>=, nie >

def is_wall_collision(head, *, half=280):
    x, y = head
    return abs(x) > half or abs(y) > half

grow = head == state.food
if is_self_collision(head, state.snake[1:]):   # PRZED move_snake()!
    state.status = GameStatus.GAME_OVER

new_snake = move_snake(state.snake, head, grow=grow)
if is_self_collision(head, new_snake[1:]):
    state.status = GameStatus.GAME_OVER

def restart(self):
    self.state = new_game_state(self.rng)
    self.render()
    #generation nie powiększone – stary _on_timer() wciąż jest planowany!

def restart(self):
    self._generation += 1
    self.state = new_game_state(self.rng, high_score=self.state.high_score)
    self.render()

def toggle_pause(self):
    self._show_overlay(„PAUZA”, „Space kontynuować”)
    # state.status niezmienione – game_tick() nic nie wie o pauzie!

def toggle_pause(self):
    if self.state.status is GameStatus.RUNNING:
        self.state.status = GameStatus.PAUSED
        self._show_overlay(„PAUZA”, „Space kontynuować”)

def restart(self):
    self._generation += 1
    self.state.snake = [(0, 0)]   # poprawia pole punktowo, a nie tworzy state od nowa
    self.state.score = 0
    # direction/next_direction pozostały z poprzedniej gry!

def restart(self):
    self._generation += 1
    self.state = new_game_state(self.rng, high_score=self.state.high_score)

def restart(self):
    self._generation += 1
    self.state = new_game_state(self.rng)   # high_score nie przekazano — znowu 0!

def restart(self):
    self._generation += 1
    self.state = new_game_state(self.rng, high_score=self.state.high_score)

@dataclass
class GameState:
    snake: list[Position]
    head_turtle: turtle.Turtle   # obiekt Turtle wewnątrz modelu!

@dataclass
class GameState:
    snake: list[Position]
    # obiekty Turtle żyć w SnakeApp, a nie w GameState

def _on_timer(self, generation):
    if generation != self._generation:
        return
    self.game_tick()
    self._schedule_next_tick()   # brak sprawdzania statusu!

def _on_timer(self, generation):
    if generation != self._generation:
        return
    self.game_tick()
    if self.state.status is GameStatus.RUNNING:
        self._schedule_next_tick()