package com.dawciobiel.pacman;<br />
<br />
import javafx.animation.AnimationTimer;<br />
import javafx.application.Application;<br />
import javafx.scene.Scene;<br />
import javafx.scene.canvas.Canvas;<br />
import javafx.scene.canvas.GraphicsContext;<br />
import javafx.scene.input.KeyCode;<br />
import javafx.scene.layout.BorderPane;<br />
import javafx.scene.paint.Color;<br />
import javafx.scene.shape.ArcType;<br />
import javafx.scene.text.Font;<br />
import javafx.stage.Stage;<br />
<br />
import java.util.ArrayList;<br />
import java.util.Iterator;<br />
import java.util.List;<br />
import java.util.Random;<br />
<br />
import static com.dawciobiel.pacman.PacmanGame.BOARD_COLS;<br />
import static com.dawciobiel.pacman.PacmanGame.BOARD_ROWS;<br />
import static com.dawciobiel.pacman.PacmanGame.SCATTER_TARGETS;<br />
<br />
<br />
enum Direction {<br />
    UP(0, -1), DOWN(0, 1), LEFT(-1, 0), RIGHT(1, 0);<br />
<br />
    public final int dx;<br />
    public final int dy;<br />
<br />
    Direction(int dx, int dy) {<br />
        this.dx = dx;<br />
        this.dy = dy;<br />
    }<br />
}<br />
<br />
enum GhostMode {<br />
    NORMAL, FRIGHTENED, SCATTER, CHASE, DEAD<br />
}<br />
<br />
public class PacmanGame extends Application {<br />
<br />
<br />
    static final int TILE_SIZE = 50;<br />
    static final double MOVEMENT_SPEED = 0.1;<br />
    // OPTYMALIZACJA: Re-używalne obiekty<br />
    static final Random SHARED_RANDOM = new Random();<br />
    private static final int BOARD_WIDTH = 1200;<br />
    static final int BOARD_COLS = BOARD_WIDTH / TILE_SIZE;<br />
    private static final int BOARD_HEIGHT = 800;<br />
    static final int BOARD_ROWS = BOARD_HEIGHT / TILE_SIZE;<br />
    // Pozycje rogów dla scatter mode<br />
    protected static final int[][] SCATTER_TARGETS = {{BOARD_COLS - 1, 0},        // czerwony — prawy górny<br />
            {0, 0},                     // różowy — lewy górny<br />
            {BOARD_COLS - 1, BOARD_ROWS - 1}, // cyan — prawy dolny<br />
            {0, BOARD_ROWS - 1}         // pomarańczowy — lewy dolny<br />
    };<br />
    private static final Font UI_FONT = new Font("Arial", 20);<br />
    private static final Font GAME_OVER_FONT = new Font("Arial", 40);<br />
    // Power pellet settings<br />
    private static final int POWER_PELLET_DURATION = 10000; // 10 sekund w milisekundach<br />
    private static final int GHOST_POINTS = 200; // Punkty za zjedzenie ducha<br />
    // OPTYMALIZACJA: Object pooling dla kierunków<br />
    private static final Direction[] DIRECTION_VALUES = Direction.values();<br />
    private static final int[][] MAZE_DIRECTIONS = {{0, -2}, {0, 2}, {-2, 0}, {2, 0}};<br />
    // OPTYMALIZACJA: Bufory do wielokrotnego użytku<br />
    private final List<int[]> stackBuffer = new ArrayList<>(100);<br />
    private final List<int[]> neighborsBuffer = new ArrayList<>(4);<br />
    private final List<Direction> validDirectionsBuffer = new ArrayList<>(4);<br />
    private SoundManager soundManager;<br />
    private Canvas canvas;<br />
    private GraphicsContext gc;<br />
    private AnimationTimer gameLoop;<br />
    private Player pacman;<br />
    private List<Ghost> ghosts;<br />
    private List<Food> foods;<br />
    private List<PowerPellet> powerPellets;<br />
    private boolean[][] walls;<br />
    private int score = 0;<br />
    private int lives = 3;<br />
    private boolean gameOver = false;<br />
    private boolean gameWon = false;<br />
    private long powerPelletStartTime = 0;<br />
    private boolean isPowerPelletActive = false;<br />
    private int ghostMultiplier = 1; // Mnożnik punktów za duchy<br />
<br />
    public static void main(String[] args) {<br />
        launch(args);<br />
    }<br />
<br />
    @Override<br />
    public void start(Stage primaryStage) {<br />
        BorderPane root = new BorderPane();<br />
        canvas = new Canvas(BOARD_WIDTH, BOARD_HEIGHT);<br />
        gc = canvas.getGraphicsContext2D();<br />
<br />
        root.setCenter(canvas);<br />
<br />
        Scene scene = new Scene(root, BOARD_WIDTH, BOARD_HEIGHT);<br />
        scene.setOnKeyPressed(e -> handleKeyPress(e.getCode()));<br />
<br />
        primaryStage.setTitle("Pacman Game - Enhanced");<br />
        primaryStage.setScene(scene);<br />
        primaryStage.setResizable(false);<br />
        primaryStage.show();<br />
<br />
        canvas.requestFocus();<br />
<br />
        initializeGame();<br />
        soundManager = SoundManager.getInstance();<br />
        startGameLoop();<br />
    }<br />
<br />
    private void initializeGame() {<br />
        // OPTYMALIZACJA: Wyczyść istniejące listy, zamiast tworzyć nowe<br />
        if (ghosts != null) {<br />
            ghosts.clear();<br />
        } else {<br />
            ghosts = new ArrayList<>(4);<br />
        }<br />
<br />
        if (foods != null) {<br />
            foods.clear();<br />
        } else {<br />
            foods = new ArrayList<>(200);<br />
        }<br />
<br />
        if (powerPellets != null) {<br />
            powerPellets.clear();<br />
        } else {<br />
            powerPellets = new ArrayList<>(4);<br />
        }<br />
<br />
        // Inicjalizacja ścian - reużywanie tablicy jeśli możliwe<br />
        if (walls == null) {<br />
            walls = new boolean[BOARD_COLS][BOARD_ROWS];<br />
        }<br />
        createMaze();<br />
<br />
        pacman = new Player(1, 1);<br />
<br />
        // Dodaj duchy z predefiniowanymi kolorami<br />
        ghosts.add(new Ghost(BOARD_COLS - 2, 1, Color.RED));<br />
        ghosts.add(new Ghost(BOARD_COLS - 2, BOARD_ROWS - 2, Color.PINK));<br />
        ghosts.add(new Ghost(1, BOARD_ROWS - 2, Color.CYAN));<br />
<br />
        createFood();<br />
        createPowerPellets();<br />
<br />
        // Reset power pellet state<br />
        isPowerPelletActive = false;<br />
        powerPelletStartTime = 0;<br />
        ghostMultiplier = 1;<br />
    }<br />
<br />
    private void createMaze() {<br />
        // OPTYMALIZACJA: Zresetuj tablicę zamiast tworzyć nową<br />
        for (int x = 0; x < BOARD_COLS; x++) {<br />
            for (int y = 0; y < BOARD_ROWS; y++) {<br />
                walls[x][y] = true;<br />
            }<br />
        }<br />
<br />
        generateMaze(1, 1);<br />
<br />
        int middleY = BOARD_ROWS / 2;<br />
        walls[0][middleY] = false;<br />
        walls[BOARD_COLS - 1][middleY] = false;<br />
<br />
        ensureTunnelAccess(middleY);<br />
<br />
        clearArea(1, 1, 2);<br />
        clearArea(BOARD_COLS - 2, 1, 1);<br />
        clearArea(BOARD_COLS - 2, BOARD_ROWS - 2, 1);<br />
        clearArea(1, BOARD_ROWS - 2, 1);<br />
<br />
        createOpenAreasAsCross();<br />
    }<br />
<br />
    private void ensureTunnelAccess(int tunnelRow) {<br />
        walls[1][tunnelRow] = false;<br />
        walls[BOARD_COLS - 2][tunnelRow] = false;<br />
    }<br />
<br />
    private void generateMaze(int startX, int startY) {<br />
        // OPTYMALIZACJA: Re-używanie buforów<br />
        stackBuffer.clear();<br />
        boolean[][] visited = new boolean[BOARD_COLS][BOARD_ROWS];<br />
<br />
        walls[startX][startY] = false;<br />
        visited[startX][startY] = true;<br />
        stackBuffer.add(new int[]{startX, startY});<br />
<br />
        while (!stackBuffer.isEmpty()) {<br />
            int[] current = stackBuffer.get(stackBuffer.size() - 1);<br />
            int currentX = current[0];<br />
            int currentY = current[1];<br />
<br />
            // OPTYMALIZACJA: Reużywanie bufora sąsiadów<br />
            neighborsBuffer.clear();<br />
<br />
            for (int[] dir : MAZE_DIRECTIONS) {<br />
                int newX = currentX + dir[0];<br />
                int newY = currentY + dir[1];<br />
<br />
                if (newX > 0 && newX < BOARD_COLS - 1 && newY > 0 && newY < BOARD_ROWS - 1 && !visited[newX][newY]) {<br />
                    neighborsBuffer.add(new int[]{newX, newY});<br />
                }<br />
            }<br />
<br />
            if (!neighborsBuffer.isEmpty()) {<br />
                int[] chosen = neighborsBuffer.get(SHARED_RANDOM.nextInt(neighborsBuffer.size()));<br />
                int chosenX = chosen[0];<br />
                int chosenY = chosen[1];<br />
<br />
                int wallX = currentX + (chosenX - currentX) / 2;<br />
                int wallY = currentY + (chosenY - currentY) / 2;<br />
<br />
                walls[chosenX][chosenY] = false;<br />
                walls[wallX][wallY] = false;<br />
                visited[chosenX][chosenY] = true;<br />
<br />
                stackBuffer.add(chosen);<br />
            } else {<br />
                stackBuffer.remove(stackBuffer.size() - 1);<br />
            }<br />
        }<br />
    }<br />
<br />
    private void clearArea(int centerX, int centerY, int radius) {<br />
        for (int x = centerX - radius; x <= centerX + radius; x++) {<br />
            for (int y = centerY - radius; y <= centerY + radius; y++) {<br />
                if (x > 0 && x < BOARD_COLS - 1 && y > 0 && y < BOARD_ROWS - 1) {<br />
                    walls[x][y] = false;<br />
                }<br />
            }<br />
        }<br />
    }<br />
<br />
    private void createOpenAreasAsCross() {<br />
        int numAreas = 3 + SHARED_RANDOM.nextInt(3);<br />
<br />
        for (int i = 0; i < numAreas; i++) {<br />
            int centerX = 3 + SHARED_RANDOM.nextInt(BOARD_COLS - 6);<br />
            int centerY = 3 + SHARED_RANDOM.nextInt(BOARD_ROWS - 6);<br />
<br />
            walls[centerX][centerY] = false;<br />
            walls[centerX - 1][centerY] = false;<br />
            walls[centerX + 1][centerY] = false;<br />
            walls[centerX][centerY - 1] = false;<br />
            walls[centerX][centerY + 1] = false;<br />
        }<br />
    }<br />
<br />
    private void createFood() {<br />
        for (int x = 1; x < BOARD_COLS - 1; x++) {<br />
            for (int y = 1; y < BOARD_ROWS - 1; y++) {<br />
                if (!walls[x][y] && !(x == 1 && y == 1)) {<br />
                    foods.add(new Food(x, y));<br />
                }<br />
            }<br />
        }<br />
    }<br />
<br />
    private void createPowerPellets() {<br />
        // Dodaj power pellets w rogach labiryntu<br />
        List<int[]> corners = new ArrayList<>();<br />
        corners.add(new int[]{3, 3});<br />
        corners.add(new int[]{BOARD_COLS - 4, 3});<br />
        corners.add(new int[]{3, BOARD_ROWS - 4});<br />
        corners.add(new int[]{BOARD_COLS - 4, BOARD_ROWS - 4});<br />
<br />
        for (int[] corner : corners) {<br />
            int x = corner[0];<br />
            int y = corner[1];<br />
<br />
            // Znajdź najbliższe wolne miejsce<br />
            for (int radius = 0; radius < 5; radius++) {<br />
                for (int dx = -radius; dx <= radius; dx++) {<br />
                    for (int dy = -radius; dy <= radius; dy++) {<br />
                        int checkX = x + dx;<br />
                        int checkY = y + dy;<br />
<br />
                        if (checkX > 0 && checkX < BOARD_COLS - 1 && checkY > 0 && checkY < BOARD_ROWS - 1 && !walls[checkX][checkY]) {<br />
<br />
                            powerPellets.add(new PowerPellet(checkX, checkY));<br />
<br />
                            // Usuń zwykłe jedzenie z tego miejsca<br />
                            foods.removeIf(food -> food.x() == checkX && food.y() == checkY);<br />
<br />
                            radius = 5; // Przerwij pętle<br />
                            dx = radius + 1;<br />
                            dy = radius + 1;<br />
                        }<br />
                    }<br />
                }<br />
            }<br />
        }<br />
    }<br />
<br />
    private void handleKeyPress(KeyCode keyCode) {<br />
        if (gameOver || gameWon) {<br />
            if (keyCode == KeyCode.R) {<br />
                restartGame();<br />
            }<br />
            return;<br />
        }<br />
<br />
        if (keyCode == KeyCode.M) {<br />
            soundManager.setSoundEnabled(!soundManager.isSoundEnabled());<br />
            return;<br />
        }<br />
<br />
        Direction newDirection = switch (keyCode) {<br />
            case UP, W -> Direction.UP;<br />
            case DOWN, S -> Direction.DOWN;<br />
            case LEFT, A -> Direction.LEFT;<br />
            case RIGHT, D -> Direction.RIGHT;<br />
            default -> null;<br />
        };<br />
<br />
        if (newDirection != null) {<br />
            pacman.queueDirection(newDirection);<br />
        }<br />
    }<br />
<br />
    private void restartGame() {<br />
        score = 0;<br />
        lives = 3;<br />
        gameOver = false;<br />
        gameWon = false;<br />
        initializeGame();<br />
        if (gameLoop != null) {<br />
            gameLoop.stop();<br />
        }<br />
        startGameLoop();<br />
    }<br />
<br />
    private void startGameLoop() {<br />
        gameLoop = new AnimationTimer() {<br />
            @Override<br />
            public void handle(long now) {<br />
                update(now);<br />
                render();<br />
            }<br />
        };<br />
        gameLoop.start();<br />
    }<br />
<br />
    private void update(long currentTime) {<br />
        if (gameOver || gameWon) return;<br />
<br />
        // Sprawdź, czy power pellet wygasł<br />
        if (isPowerPelletActive && currentTime - powerPelletStartTime > POWER_PELLET_DURATION * 1_000_000L) {<br />
            isPowerPelletActive = false;<br />
            ghostMultiplier = 1;<br />
<br />
            // Przywróć normalny tryb duchów<br />
            for (Ghost ghost : ghosts) {<br />
                ghost.setMode(GhostMode.NORMAL);<br />
            }<br />
        }<br />
<br />
        pacman.update(walls);<br />
<br />
        for (Ghost ghost : ghosts) {<br />
            ghost.update(walls, pacman.getTileX(), pacman.getTileY(), isPowerPelletActive, pacman.getDirection());<br />
        }<br />
<br />
        // OPTYMALIZACJA: Sprawdź kolizje z jedzeniem tylko, gdy Pacman jest w centrum<br />
        if (pacman.isAtTileCenter()) {<br />
            // Sprawdź kolizje ze zwykłym jedzeniem<br />
            Iterator<Food> foodIterator = foods.iterator();<br />
            while (foodIterator.hasNext()) {<br />
                Food food = foodIterator.next();<br />
                if (food.x() == pacman.getTileX() && food.y() == pacman.getTileY()) {<br />
                    score += 10;<br />
                    foodIterator.remove();<br />
                    soundManager.playSound("chomp"); // DODANE<br />
                }<br />
            }<br />
<br />
            // Sprawdź kolizje z power pellets<br />
            Iterator<PowerPellet> powerPelletIterator = powerPellets.iterator();<br />
            while (powerPelletIterator.hasNext()) {<br />
                PowerPellet powerPellet = powerPelletIterator.next();<br />
                if (powerPellet.x() == pacman.getTileX() && powerPellet.y() == pacman.getTileY()) {<br />
                    score += 50;<br />
                    powerPelletIterator.remove();<br />
                    soundManager.playSound("power_pellet");<br />
<br />
                    // Aktywuj power pellet<br />
                    isPowerPelletActive = true;<br />
                    powerPelletStartTime = currentTime;<br />
                    ghostMultiplier = 1;<br />
<br />
                    // Zmień tryb duchów na frightened<br />
                    for (Ghost ghost : ghosts) {<br />
                        ghost.setMode(GhostMode.FRIGHTENED);<br />
                    }<br />
                }<br />
            }<br />
        }<br />
<br />
        // Sprawdź kolizje z duchami<br />
        Iterator<Ghost> ghostIterator = ghosts.iterator();<br />
        while (ghostIterator.hasNext()) {<br />
            Ghost ghost = ghostIterator.next();<br />
            double dx = ghost.getDrawX() - pacman.getDrawX();<br />
            double dy = ghost.getDrawY() - pacman.getDrawY();<br />
            double distanceSquared = dx * dx + dy * dy;<br />
<br />
            if (distanceSquared < (TILE_SIZE * 0.8) * (TILE_SIZE * 0.8)) {<br />
                if (isPowerPelletActive && ghost.getMode() == GhostMode.FRIGHTENED) {<br />
                    // Zjadanie ducha<br />
                    score += GHOST_POINTS * ghostMultiplier;<br />
                    ghostMultiplier *= 2; // Podwajaj punkty za kolejne duchy<br />
                    soundManager.playSound("ghost_eaten");<br />
<br />
                    ghost.setModeDead();<br />
                } else if (ghost.getMode() != GhostMode.DEAD) { // DODANE: Nie zabijaj jeśli duch jest martwy<br />
                    // Pacman zostaje zjedzony<br />
                    lives--;<br />
                    soundManager.playSound("death");<br />
                    if (lives <= 0) {<br />
                        gameOver = true;<br />
                        soundManager.playSound("game_over");<br />
                        gameLoop.stop();<br />
                        return;<br />
                    } else {<br />
                        // Restart pozycji<br />
                        pacman.reset(1, 1);<br />
                        isPowerPelletActive = false;<br />
                        ghostMultiplier = 1;<br />
<br />
                        // Przywróć normalny tryb duchów<br />
                        for (Ghost g : ghosts) {<br />
                            g.setMode(GhostMode.SCATTER);<br />
                        }<br />
                    }<br />
                }<br />
            }<br />
        }<br />
<br />
        // Sprawdź warunek wygranej<br />
        if (foods.isEmpty() && powerPellets.isEmpty()) {<br />
            gameWon = true;<br />
            soundManager.playSound("level_complete");<br />
            gameLoop.stop();<br />
        }<br />
    }<br />
<br />
    private void render() {<br />
        // Wyczyść ekran<br />
        gc.setFill(Color.BLACK);<br />
        gc.fillRect(0, 0, BOARD_WIDTH, BOARD_HEIGHT);<br />
<br />
        // Narysuj ściany<br />
        gc.setFill(Color.BLUE);<br />
        for (int x = 0; x < BOARD_COLS; x++) {<br />
            for (int y = 0; y < BOARD_ROWS; y++) {<br />
                if (walls[x][y]) {<br />
                    gc.fillRect(x * TILE_SIZE, y * TILE_SIZE, TILE_SIZE, TILE_SIZE);<br />
                }<br />
            }<br />
        }<br />
<br />
        // Narysuj jedzenie<br />
        gc.setFill(Color.GHOSTWHITE);<br />
        for (Food food : foods) {<br />
            double foodX = food.x() * TILE_SIZE + TILE_SIZE * 0.25;<br />
            double foodY = food.y() * TILE_SIZE + TILE_SIZE * 0.25;<br />
            double foodSize = TILE_SIZE * 0.5;<br />
            gc.fillOval(foodX, foodY, foodSize, foodSize);<br />
        }<br />
<br />
        // Narysuj power pellets<br />
        gc.setFill(Color.YELLOW);<br />
        for (PowerPellet powerPellet : powerPellets) {<br />
            double pelletX = powerPellet.x() * TILE_SIZE + TILE_SIZE * 0.15;<br />
            double pelletY = powerPellet.y() * TILE_SIZE + TILE_SIZE * 0.15;<br />
            double pelletSize = TILE_SIZE * 0.7;<br />
            gc.fillOval(pelletX, pelletY, pelletSize, pelletSize);<br />
        }<br />
<br />
        pacman.draw(gc);<br />
<br />
        // Narysuj duchy<br />
        for (Ghost ghost : ghosts) {<br />
            Color ghostColor;<br />
            if (ghost.getMode() == GhostMode.FRIGHTENED) {<br />
                ghostColor = Color.BLUE;<br />
            } else if (ghost.getMode() == GhostMode.DEAD) {<br />
                ghostColor = Color.GRAY; // Inny kolor dla martwych duchów<br />
            } else {<br />
                ghostColor = ghost.getColor();<br />
            }<br />
<br />
            gc.setFill(ghostColor);<br />
            double ghostX = ghost.getDrawX() - TILE_SIZE * 0.5 + 2;<br />
            double ghostY = ghost.getDrawY() - TILE_SIZE * 0.5 + 2;<br />
            double ghostSize = TILE_SIZE - 4;<br />
            gc.fillRect(ghostX, ghostY, ghostSize, ghostSize);<br />
        }<br />
<br />
        // UI<br />
        gc.setFill(Color.WHITE);<br />
        gc.setFont(UI_FONT);<br />
        gc.fillText("Wynik: " + score, 10, 25);<br />
        gc.fillText("Życia: " + lives, 10, 50);<br />
<br />
        if (isPowerPelletActive) {<br />
            gc.fillText("POWER MODE!", 10, 75);<br />
        }<br />
<br />
        if (gameOver) {<br />
            gc.setFont(GAME_OVER_FONT);<br />
            gc.fillText("GAME OVER!", BOARD_WIDTH * 0.5 - 120, BOARD_HEIGHT * 0.5);<br />
            gc.setFont(UI_FONT);<br />
            gc.fillText("Naciśnij R aby zagrać ponownie", BOARD_WIDTH * 0.5 - 120, BOARD_HEIGHT * 0.5 + 40);<br />
        } else if (gameWon) {<br />
            gc.setFont(GAME_OVER_FONT);<br />
            gc.fillText("WYGRAŁEŚ!", BOARD_WIDTH * 0.5 - 100, BOARD_HEIGHT * 0.5);<br />
            gc.setFont(UI_FONT);<br />
            gc.fillText("Naciśnij R aby zagrać ponownie", BOARD_WIDTH * 0.5 - 120, BOARD_HEIGHT * 0.5 + 40);<br />
        }<br />
    }<br />
<br />
    @Override<br />
    public void stop() throws Exception {<br />
        if (gameLoop != null) {<br />
            gameLoop.stop();<br />
        }<br />
        if (soundManager != null) {<br />
            soundManager.cleanup(); // DODANE<br />
        }<br />
        super.stop();<br />
    }<br />
}<br />
<br />
class Player {<br />
    private static final double ANIMATION_SPEED = 0.15;<br />
    private final int startX;<br />
    private final int startY;<br />
    private double x;<br />
    private double y;<br />
    private int tileX;<br />
    private int tileY;<br />
    private Direction direction = Direction.RIGHT;<br />
    private Direction queuedDirection = null;<br />
    private boolean isMoving = false;<br />
    private double moveProgress = 0.0;<br />
    private double animationTime = 0.0;<br />
<br />
    public Player(int startX, int startY) {<br />
        this.startX = startX;<br />
        this.startY = startY;<br />
        this.tileX = startX;<br />
        this.tileY = startY;<br />
        this.x = startX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        this.y = startY * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
    }<br />
<br />
    public void reset(int newX, int newY) {<br />
        this.tileX = newX;<br />
        this.tileY = newY;<br />
        this.x = newX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        this.y = newY * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        this.direction = Direction.RIGHT;<br />
        this.queuedDirection = null;<br />
        this.isMoving = false;<br />
        this.moveProgress = 0.0;<br />
        this.animationTime = 0.0;<br />
    }<br />
<br />
    public void draw(GraphicsContext gc) {<br />
        double startAngle = switch (direction) {<br />
            case RIGHT -> 0;<br />
            case DOWN -> 270;<br />
            case LEFT -> 180;<br />
            case UP -> 90;<br />
        };<br />
<br />
        double mouthAngle = 45 * Math.sin(animationTime * Math.PI * 2);<br />
        if (mouthAngle < 0) mouthAngle = 0;<br />
<br />
        double drawX = getDrawX() - PacmanGame.TILE_SIZE * 0.5 + 2;<br />
        double drawY = getDrawY() - PacmanGame.TILE_SIZE * 0.5 + 2;<br />
        double size = PacmanGame.TILE_SIZE - 4;<br />
<br />
        gc.setFill(Color.YELLOW);<br />
<br />
        if (mouthAngle > 0) {<br />
            gc.fillArc(drawX, drawY, size, size, startAngle + mouthAngle * 0.5, 360 - mouthAngle, ArcType.ROUND);<br />
        } else {<br />
            gc.fillOval(drawX, drawY, size, size);<br />
        }<br />
    }<br />
<br />
    public void update(boolean[][] walls) {<br />
        if (isMoving) {<br />
            animationTime += ANIMATION_SPEED;<br />
            if (animationTime >= 1.0) {<br />
                animationTime = 0.0;<br />
            }<br />
        }<br />
<br />
        if (queuedDirection != null && !isMoving) {<br />
            if (canMove(queuedDirection, walls)) {<br />
                direction = queuedDirection;<br />
                queuedDirection = null;<br />
                startMoving();<br />
            }<br />
        }<br />
<br />
        if (!isMoving && canMove(direction, walls)) {<br />
            startMoving();<br />
        }<br />
<br />
        if (isMoving) {<br />
            moveProgress += PacmanGame.MOVEMENT_SPEED;<br />
<br />
            if (moveProgress >= 1.0) {<br />
                completeMove();<br />
                moveProgress = 0.0;<br />
                isMoving = false;<br />
                handleTunnels();<br />
            } else {<br />
                updateInterpolatedPosition();<br />
            }<br />
        }<br />
    }<br />
<br />
    private void startMoving() {<br />
        isMoving = true;<br />
        moveProgress = 0.0;<br />
    }<br />
<br />
    private void completeMove() {<br />
        tileX += direction.dx;<br />
        tileY += direction.dy;<br />
<br />
        x = tileX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        y = tileY * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
    }<br />
<br />
    private void updateInterpolatedPosition() {<br />
        double startX = tileX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        double startY = tileY * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
<br />
        double targetX = startX + direction.dx * PacmanGame.TILE_SIZE;<br />
        double targetY = startY + direction.dy * PacmanGame.TILE_SIZE;<br />
<br />
        x = startX + (targetX - startX) * moveProgress;<br />
        y = startY + (targetY - startY) * moveProgress;<br />
    }<br />
<br />
    private boolean canMove(Direction dir, boolean[][] walls) {<br />
        int nextX = tileX + dir.dx;<br />
        int nextY = tileY + dir.dy;<br />
<br />
        if (nextX < 0 || nextX >= walls.length || nextY < 0 || nextY >= walls[0].length) {<br />
            return (nextX < 0 || nextX >= walls.length) && nextY == BOARD_ROWS / 2;<br />
        }<br />
<br />
        return !walls[nextX][nextY];<br />
    }<br />
<br />
    private void handleTunnels() {<br />
        if (tileX < 0) {<br />
            tileX = BOARD_COLS - 1;<br />
            x = tileX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        } else if (tileX >= BOARD_COLS) {<br />
            tileX = 0;<br />
            x = tileX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        }<br />
    }<br />
<br />
    public void queueDirection(Direction newDirection) {<br />
        this.queuedDirection = newDirection;<br />
    }<br />
<br />
    public boolean isAtTileCenter() {<br />
        return !isMoving;<br />
    }<br />
<br />
    public double getDrawX() {<br />
        return x;<br />
    }<br />
<br />
    public double getDrawY() {<br />
        return y;<br />
    }<br />
<br />
    public int getTileX() {<br />
        return tileX;<br />
    }<br />
<br />
    public int getTileY() {<br />
        return tileY;<br />
    }<br />
<br />
    public Direction getDirection() {<br />
        return direction;<br />
    }<br />
}<br />
<br />
class Ghost {<br />
<br />
<br />
    private static final int SCATTER_DURATION = 420; // 7 sekund * 60 FPS<br />
    private static final int CHASE_DURATION = 1200;  // 20 sekund * 60 FPS<br />
    private static final int HOME_X = BOARD_COLS / 2;<br />
    private static final int HOME_Y = BOARD_ROWS / 2;<br />
    private final Color originalColor;<br />
    private final List<Direction> validDirections = new ArrayList<>(4);<br />
    private final int startX;<br />
    private final int startY;<br />
    private final int scatterTargetX;<br />
    private final int scatterTargetY;<br />
    private final int ghostIndex; // 0-3 dla różnych strategii<br />
    private double x;<br />
    private double y;<br />
    private int tileX;<br />
    private int tileY;<br />
    private Direction direction;<br />
    private boolean isMoving = false;<br />
    private double moveProgress = 0.0;<br />
    private GhostMode mode = GhostMode.SCATTER;<br />
    private int modeTimer = 0;<br />
<br />
<br />
    public Ghost(int startX, int startY, Color color) {<br />
        this.startX = startX;<br />
        this.startY = startY;<br />
        this.tileX = startX;<br />
        this.tileY = startY;<br />
        this.x = startX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        this.y = startY * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        this.originalColor = color;<br />
        this.direction = Direction.values()[PacmanGame.SHARED_RANDOM.nextInt(4)];<br />
        // Przypisz indeks na podstawie koloru<br />
        if (color.equals(Color.RED)) this.ghostIndex = 0;<br />
        else if (color.equals(Color.PINK)) this.ghostIndex = 1;<br />
        else if (color.equals(Color.CYAN)) this.ghostIndex = 2;<br />
        else this.ghostIndex = 3;<br />
<br />
        // Przypisz cel scatter<br />
        this.scatterTargetX = SCATTER_TARGETS[ghostIndex][0];<br />
        this.scatterTargetY = SCATTER_TARGETS[ghostIndex][1];<br />
<br />
    }<br />
<br />
    // 4. Nowa metoda do zarządzania stanami (dodaj do klasy Ghost)<br />
    private void updateMode() {<br />
        if (mode == GhostMode.FRIGHTENED || mode == GhostMode.DEAD) {<br />
            return; // Nie zmieniaj automatycznie w tych trybach<br />
        }<br />
<br />
        modeTimer++;<br />
<br />
        if (mode == GhostMode.SCATTER && modeTimer >= SCATTER_DURATION) {<br />
            mode = GhostMode.CHASE;<br />
            modeTimer = 0;<br />
        } else if (mode == GhostMode.CHASE && modeTimer >= CHASE_DURATION) {<br />
            mode = GhostMode.SCATTER;<br />
            modeTimer = 0;<br />
        }<br />
    }<br />
<br />
    // 5. Nowa metoda do wybierania celu (dodaj do klasy Ghost)<br />
    private int[] getTarget(int pacmanX, int pacmanY, Direction pacmanDirection) {<br />
        switch (mode) {<br />
            case SCATTER:<br />
                return new int[]{scatterTargetX, scatterTargetY};<br />
<br />
            case CHASE:<br />
                return getChaseTarget(pacmanX, pacmanY, pacmanDirection);<br />
<br />
            case FRIGHTENED:<br />
                return null; // Losowy ruch<br />
<br />
            case DEAD:<br />
                return new int[]{HOME_X, HOME_Y};<br />
<br />
            default:<br />
                return new int[]{scatterTargetX, scatterTargetY};<br />
        }<br />
    }<br />
<br />
    // 6. Metoda do strategii ścigania (dodaj do klasy Ghost)<br />
    private int[] getChaseTarget(int pacmanX, int pacmanY, Direction pacmanDirection) {<br />
        switch (ghostIndex) {<br />
            case 0: // Czerwony (Blinky) - bezpośrednio do Pacmana<br />
                return new int[]{pacmanX, pacmanY};<br />
<br />
            case 1: // Różowy (Pinky) - 4 pola przed Pacmanem<br />
                int targetX = pacmanX;<br />
                int targetY = pacmanY;<br />
                switch (pacmanDirection) {<br />
                    case LEFT:<br />
                        targetX -= 4;<br />
                        break;<br />
                    case RIGHT:<br />
                        targetX += 4;<br />
                        break;<br />
                    case UP:<br />
                        targetY -= 4;<br />
                        break;<br />
                    case DOWN:<br />
                        targetY += 4;<br />
                        break;<br />
                }<br />
                return new int[]{targetX, targetY};<br />
<br />
            case 2: // Cyan (Inky) - 2 pola przed Pacmanem<br />
                targetX = pacmanX;<br />
                targetY = pacmanY;<br />
                switch (pacmanDirection) {<br />
                    case LEFT:<br />
                        targetX -= 2;<br />
                        break;<br />
                    case RIGHT:<br />
                        targetX += 2;<br />
                        break;<br />
                    case UP:<br />
                        targetY -= 2;<br />
                        break;<br />
                    case DOWN:<br />
                        targetY += 2;<br />
                        break;<br />
                }<br />
                return new int[]{targetX, targetY};<br />
<br />
            case 3: // Pomarańczowy (Clyde) - jeśli daleko to jak Blinky, jeśli blisko to scatter<br />
                double distance = Math.sqrt((tileX - pacmanX) * (tileX - pacmanX) + (tileY - pacmanY) * (tileY - pacmanY));<br />
                if (distance > 8) {<br />
                    return new int[]{pacmanX, pacmanY};<br />
                } else {<br />
                    return new int[]{scatterTargetX, scatterTargetY};<br />
                }<br />
<br />
            default:<br />
                return new int[]{pacmanX, pacmanY};<br />
        }<br />
    }<br />
<br />
    // 7. Nowa metoda do ruchu w kierunku celu (dodaj do klasy Ghost)<br />
    private Direction getBestDirectionToTarget(int[] target, boolean[][] walls) {<br />
        if (target == null) return null;<br />
<br />
        Direction bestDirection = direction;<br />
        double shortestDistance = Double.MAX_VALUE;<br />
<br />
        for (Direction dir : Direction.values()) {<br />
            // Nie cofaj się (chyba że musisz)<br />
            if (getOppositeDirection(dir) == direction && validDirections.size() > 1) {<br />
                continue;<br />
            }<br />
<br />
            if (canMove(dir, walls)) {<br />
                int nextX = tileX + dir.dx;<br />
                int nextY = tileY + dir.dy;<br />
                double distance = Math.sqrt((nextX - target[0]) * (nextX - target[0]) + (nextY - target[1]) * (nextY - target[1]));<br />
<br />
                if (distance < shortestDistance) {<br />
                    shortestDistance = distance;<br />
                    bestDirection = dir;<br />
                }<br />
            }<br />
        }<br />
<br />
        return bestDirection;<br />
    }<br />
<br />
    // 8. Metoda pomocnicza dla kierunków przeciwnych (dodaj do klasy Ghost)<br />
    private Direction getOppositeDirection(Direction dir) {<br />
        switch (dir) {<br />
            case UP:<br />
                return Direction.DOWN;<br />
            case DOWN:<br />
                return Direction.UP;<br />
            case LEFT:<br />
                return Direction.RIGHT;<br />
            case RIGHT:<br />
                return Direction.LEFT;<br />
            default:<br />
                return dir;<br />
        }<br />
    }<br />
<br />
<br />
    public void respawn(int newX, int newY) {<br />
        this.tileX = newX;<br />
        this.tileY = newY;<br />
        this.x = newX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        this.y = newY * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        this.isMoving = false;<br />
        this.moveProgress = 0.0;<br />
        this.mode = GhostMode.SCATTER;<br />
        this.modeTimer = 0;<br />
    }<br />
<br />
    public void update(boolean[][] walls, int pacmanX, int pacmanY, boolean isPowerPelletActive, Direction pacmanDirection) {<br />
        // Aktualizuj tryb tylko jeśli nie jest frightened<br />
        if (mode != GhostMode.FRIGHTENED) {<br />
            updateMode();<br />
        }<br />
<br />
        // Sprawdź, czy duch w trybie DEAD dotarł do domu<br />
        if (mode == GhostMode.DEAD) {<br />
            if (Math.abs(tileX - HOME_X) <= 1 && Math.abs(tileY - HOME_Y) <= 1) {<br />
                mode = GhostMode.SCATTER;<br />
                modeTimer = 0;<br />
            }<br />
        }<br />
<br />
        if (!isMoving) {<br />
            chooseDirection(walls, pacmanX, pacmanY, pacmanDirection);<br />
            if (canMove(direction, walls)) {<br />
                startMoving();<br />
            }<br />
        }<br />
<br />
        if (isMoving) {<br />
            moveProgress += PacmanGame.MOVEMENT_SPEED;<br />
            if (moveProgress >= 1.0) {<br />
                completeMove();<br />
                moveProgress = 0.0;<br />
                isMoving = false;<br />
                handleTunnels();<br />
            } else {<br />
                updateInterpolatedPosition();<br />
            }<br />
        }<br />
    }<br />
<br />
    public void setModeDead() {<br />
        this.mode = GhostMode.DEAD;<br />
        this.modeTimer = 0;<br />
    }<br />
<br />
    private void chooseDirection(boolean[][] walls, int pacmanX, int pacmanY, Direction pacmanDirection) {<br />
        validDirections.clear();<br />
        for (Direction dir : Direction.values()) {<br />
            if (canMove(dir, walls)) {<br />
                validDirections.add(dir);<br />
            }<br />
        }<br />
<br />
        if (!validDirections.isEmpty()) {<br />
            if (mode == GhostMode.FRIGHTENED) {<br />
                // W trybie frightened, unikaj Pacmana (istniejący kod)<br />
                Direction bestDirection = null;<br />
                double maxDistance = -1;<br />
                for (Direction dir : validDirections) {<br />
                    int nextX = tileX + dir.dx;<br />
                    int nextY = tileY + dir.dy;<br />
                    double distance = Math.sqrt((nextX - pacmanX) * (nextX - pacmanX) + (nextY - pacmanY) * (nextY - pacmanY));<br />
                    if (distance > maxDistance) {<br />
                        maxDistance = distance;<br />
                        bestDirection = dir;<br />
                    }<br />
                }<br />
                if (bestDirection != null) {<br />
                    direction = bestDirection;<br />
                } else {<br />
                    direction = validDirections.get(PacmanGame.SHARED_RANDOM.nextInt(validDirections.size()));<br />
                }<br />
            } else {<br />
                // NOWE: Scatter, Chase, Dead modes<br />
                int[] target = getTarget(pacmanX, pacmanY, pacmanDirection);<br />
                Direction bestDirection = getBestDirectionToTarget(target, walls);<br />
<br />
                if (bestDirection != null && validDirections.contains(bestDirection)) {<br />
                    direction = bestDirection;<br />
                } else {<br />
                    // Fallback — kontynuuj obecny kierunek lub wybierz losowy<br />
                    if (PacmanGame.SHARED_RANDOM.nextInt(10) < 7 && validDirections.contains(direction)) {<br />
                        // Kontynuuj obecny kierunek<br />
                    } else {<br />
                        direction = validDirections.get(PacmanGame.SHARED_RANDOM.nextInt(validDirections.size()));<br />
                    }<br />
                }<br />
            }<br />
        }<br />
    }<br />
<br />
    private void startMoving() {<br />
        isMoving = true;<br />
        moveProgress = 0.0;<br />
    }<br />
<br />
    private void completeMove() {<br />
        tileX += direction.dx;<br />
        tileY += direction.dy;<br />
<br />
        x = tileX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        y = tileY * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
    }<br />
<br />
    private void updateInterpolatedPosition() {<br />
        double startX = tileX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        double startY = tileY * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
<br />
        double targetX = startX + direction.dx * PacmanGame.TILE_SIZE;<br />
        double targetY = startY + direction.dy * PacmanGame.TILE_SIZE;<br />
<br />
        x = startX + (targetX - startX) * moveProgress;<br />
        y = startY + (targetY - startY) * moveProgress;<br />
    }<br />
<br />
    private boolean canMove(Direction dir, boolean[][] walls) {<br />
        int nextX = tileX + dir.dx;<br />
        int nextY = tileY + dir.dy;<br />
<br />
        if (nextX < 0 || nextX >= walls.length || nextY < 0 || nextY >= walls[0].length) {<br />
            return (nextX < 0 || nextX >= walls.length) && nextY == BOARD_ROWS / 2;<br />
        }<br />
<br />
        return !walls[nextX][nextY];<br />
    }<br />
<br />
    private void handleTunnels() {<br />
        if (tileX < 0) {<br />
            tileX = BOARD_COLS - 1;<br />
            x = tileX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        } else if (tileX >= BOARD_COLS) {<br />
            tileX = 0;<br />
            x = tileX * PacmanGame.TILE_SIZE + PacmanGame.TILE_SIZE * 0.5;<br />
        }<br />
    }<br />
<br />
    public GhostMode getMode() {<br />
        return mode;<br />
    }<br />
<br />
    public void setMode(GhostMode newMode) {<br />
        this.mode = newMode;<br />
    }<br />
<br />
    public double getDrawX() {<br />
        return x;<br />
    }<br />
<br />
    public double getDrawY() {<br />
        return y;<br />
    }<br />
<br />
    public int getTileX() {<br />
        return tileX;<br />
    }<br />
<br />
    public int getTileY() {<br />
        return tileY;<br />
    }<br />
<br />
    public Color getColor() {<br />
        return originalColor;<br />
    }<br />
}<br />
<br />
record Food(int x, int y) {<br />
}<br />
<br />
record PowerPellet(int x, int y) {<br />
}