Pacman positioning after resizing window Frame

Question

4 days I'm trying to figure out how to fix my Pacman movement to board. This is my project for studies. According to the project requirements, the game board (maze) must be implemented with JTable(AbstractTableModel). Moreover, the game window must be scalable, and the user chooses the number of board cells. Scaling the maze to the window works correctly. I assumed that the minimum size of a JTable cell must be 10x10 px. Due to the goal of achieving smooth animation, I do not want to render the cell in which Pacman is located, but rather ensure its movement based on px. Could any of you help me understand what is wrong? After a few days of struggling with this functionality, I'm starting to get a little stressed. I will add that there is also something wrong with the movement itself. Pacman only moves when the cells are slightly larger. Adds the code of several classes.

package view;

import model.GameModel;
import model.PacmanModel;
import util.CustomTableModel;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;

public class GameFrame extends JFrame {

    private GameModel gameModel;
    private PacmanView pacmanView;
    private GameTable gameTable;
    private JLayeredPane layeredPane;

    public GameFrame(String title, GameModel gameModel) {
        super(title);
        this.gameModel = gameModel;

        setUpFrame();
        initializeComponents();
        addEventListeners();
    }

    private void setUpFrame() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(true);
        setMaximizedBounds(new Rectangle(getMaxScreenBounds()));
        setLayout(new BorderLayout());
        setLocationRelativeTo(null);
        setVisible(true);
    }

    private void initializeComponents() {
        layeredPane = new JLayeredPane();

        CustomTableModel customTableModel = new CustomTableModel(gameModel);
        gameTable = new GameTable(customTableModel);
        gameModel.setGameTable(gameTable);
        gameModel.initializePacman();
        gameTable.setOpaque(false);
        gameTable.setFillsViewportHeight(true);

        PacmanModel pacmanModel = gameModel.getPacman();
        pacmanView = new PacmanView(pacmanModel);

        // Ustawienie początkowych wymiarów na podstawie minimalnych wymiarów komórek
        int initialWidth = gameTable.getColumnCount() * 10; // Założenie, że 10 jest minimalną szerokością komórki
        int initialHeight = gameTable.getRowCount() * 10; // Założenie, że 10 jest minimalną wysokością komórki
        setSize(initialWidth, initialHeight);
        gameModel.setInitialWidth(initialWidth);
        gameModel.setInitialHeight(initialHeight);

        layeredPane.add(gameTable, Integer.valueOf(1));
        layeredPane.add(pacmanView, Integer.valueOf(2));

        layeredPane.setOpaque(false);
        add(layeredPane);
        layeredPane.setBounds(0, 0, getWidth(), getHeight());
    }

    private void addEventListeners() {
        addComponentListener(new ComponentAdapter() {
            @Override
            public void componentResized(ComponentEvent e) {
                Dimension size = getSize();
                Insets insets = getInsets();

                int width = size.width - insets.left - insets.right;
                int height = size.height - insets.top - insets.bottom;

                int rows = gameTable.getRowCount();
                int columns = gameTable.getColumnCount();

                int minWidth = columns * 10 + insets.left + insets.right;
                int minHeight = rows * 10 + insets.top + insets.bottom;
                setMinimumSize(new Dimension(minWidth, minHeight));

                int cellWidth = Math.max(width / columns, 10);
                int cellHeight = Math.max(height / rows, 10);

                gameTable.setRowHeight(cellHeight);
                for (int i = 0; i < columns; i++) {
                    gameTable.getColumnModel().getColumn(i).setMinWidth(cellWidth);
                }

                gameTable.setSize(width, height);
                pacmanView.setBounds(0, 0, width, height);

                // Aktualizacja wymiarów Pacmana
                gameModel.getPacman().setSize(cellWidth, cellHeight);

                PacmanModel pacman = gameModel.getPacman();
                double scaleX = getWidth() / (double) gameModel.getInitialWidth();
                double scaleY = getHeight() / (double) gameModel.getInitialHeight();

                Point currentLocation = pacman.getLocation();
                int newX = (int) (currentLocation.x * scaleX);
                int newY = (int) (currentLocation.y * scaleY);
                System.out.println("Nowa pozycja Pacmana: " + newX + ", " + newY); // Logowanie dla debugowania
                pacman.setPosition(newX, newY);
            }
        });
    }

    private Rectangle getMaxScreenBounds() {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        GraphicsDevice[] gd = ge.getScreenDevices();
        Rectangle bounds = new Rectangle();

        for (GraphicsDevice device : gd) {
            GraphicsConfiguration gc = device.getDefaultConfiguration();
            bounds = bounds.union(gc.getBounds());
        }

        Insets screenInsets = getToolkit().getScreenInsets(getGraphicsConfiguration());
        bounds.x += screenInsets.left;
        bounds.y += screenInsets.top;
        bounds.width -= (screenInsets.left + screenInsets.right);
        bounds.height -= (screenInsets.top + screenInsets.bottom);

        return bounds;
    }

    public GameTable getGameTableModel() {
        return gameTable;
    }

    public PacmanView getPacmanView() {
        return pacmanView;
    }
}

package model;

import view.GameFrame;
import view.GameTable;
import view.PacmanView;

import java.awt.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class GameModel {
    private PacmanModel pacmanModel;

    private GameTable gameFrame;
    private final List<Ghost> ghosts;
    private final int GHOST_FOR_CELLS = 60;

    private Maze mazeGenerator;
    private CellType[][] maze;
    private final int rows;
    private final int cols;
    private Thread gameThread;
    private boolean isRunning = false;

    private int initialWidth, initialHeight;


    private GameTable gameTable; // zaleznosc niezbedna do uzyskania odpowiedniej przestrzeni px

    public GameModel(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;

        this.ghosts = new ArrayList<>();

        initializeMaze();
      //  initializePacman();
      //  initializeGhosts();
    }



    public void initializeGhosts() {
        EmptyCellCounter emptyCellsCounter = (CellType[][] maze) -> {
            int count = 0;
            for (CellType[] row : maze) {
                for (CellType cell : row) {
                    if (cell == CellType.EMPTY) {
                        count++;
                    }
                }
            }
            return count;
        };
        int emptyCellsNum = emptyCellsCounter.calculate(maze);
        createGhosts(emptyCellsNum / GHOST_FOR_CELLS, new int[]{5, 6, 7, 8, 9});
    }

    public void initializeMaze() {
        mazeGenerator = new Maze(rows, cols);
        generateMaze();
    }

    public void initializePacman() {
        CellFinder firstCellFinder = (CellType[][] maze) -> {
            for (int r = 0; r < maze.length; r++) {
                for (int c = 0; c < maze[0].length; c++) {
                    if (maze[r][c] == CellType.EMPTY) {
                        return new Point(c, r);
                    }
                }
            }
            return null;
        };
        Point startPoint = firstCellFinder.findFirstEmptyCell(maze);

        // Obliczanie pikselowych współrzędnych
        int cellWidth = gameTable.getColumnModel().getColumn(startPoint.x).getWidth();
        int cellHeight = gameTable.getRowHeight();
        int pixelX = startPoint.x * cellWidth;
        int pixelY = startPoint.y * cellHeight;

        assert startPoint != null;
        this.pacmanModel = new PacmanModel(this, pixelX, pixelY);
    }



    public void generateMaze() {
        mazeGenerator.generateMaze(); // Generuj labirynt
        maze = mazeGenerator.getMaze(); // Pobierz wygenerowany labirynt
    }

    private void createGhosts(int totalGhosts, int[] sectors) {
        int ghostsPerSector = totalGhosts / sectors.length;

        for (int sector : sectors) {
            for (int i = 0; i < ghostsPerSector; i++) {
                Ghost ghost = createGhostInSector(sector);
                if (ghost != null) {
                    ghosts.add(ghost);
                }
            }
        }
    }

    private Ghost createGhostInSector(int sector) {
        int sectorRowStart = ((sector - 1) / 3) * (rows / 3);
        int sectorColStart = ((sector - 1) % 3) * (cols / 3);
        int sectorRowEnd = sectorRowStart + (rows / 3);
        int sectorColEnd = sectorColStart + (cols / 3);

        Random rand = new Random();
        int row, col;
        do {
            row = rand.nextInt(sectorRowEnd - sectorRowStart) + sectorRowStart;
            col = rand.nextInt(sectorColEnd - sectorColStart) + sectorColStart;

        } while (maze[row][col] != CellType.EMPTY);

        return new Ghost(this, col, row);
    }

    public CellType getCellType(int row, int col) {
        return maze[row][col];
    }

    public PacmanModel getPacman() {
        return pacmanModel;
    }

    public List<Ghost> getGhosts() {
        return ghosts;
    }

    public int getRows() {
        return rows;
    }

    public int getCols() {
        return cols;
    }

    public CellType[][] getMaze() {
        return maze;
    }
    public Maze getMazeModel() {
        return mazeGenerator;
    }

    public void setGameTable(GameTable gameTable) {
        this.gameTable = gameTable;
    }

    public GameTable getGameTable() {
        return gameTable;
    }

    public int getInitialWidth() {
        return initialWidth;
    }

    public void setInitialWidth(int initialWidth) {
        this.initialWidth = initialWidth;
    }

    public int getInitialHeight() {
        return initialHeight;
    }

    public void setInitialHeight(int initialHeight) {
        this.initialHeight = initialHeight;
    }

}

package view;

import model.Direction;
import model.GameModel;
import model.PacmanModel;

import javax.swing.*;
import java.awt.*;

public class PacmanView extends JPanel {

    private PacmanModel pacmanModel;
    ImageIcon[][] pacmanImages;

    public PacmanView(PacmanModel pacmanModel) {

        this.pacmanModel = pacmanModel;

        setDoubleBuffered(true);
        setOpaque(false);

        this.pacmanImages = new ImageIcon[4][4];
        this.loadImages();
        pacmanFaceThread();
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        ImageIcon currentIcon = getCurrentIcon();
        int x = (int) pacmanModel.getX();
        int y = (int) pacmanModel.getY();
        int width = pacmanModel.width;
        int height = pacmanModel.height;

        g.drawImage(currentIcon.getImage(), x, y, width, height, this);
    }

    public void loadImages() {
        //up
        pacmanImages[Direction.UP.ordinal()][0] = new ImageIcon("resources/pacman/up/up_1.png");
        pacmanImages[Direction.UP.ordinal()][1] = new ImageIcon("resources/pacman/up/up_2.png");
        pacmanImages[Direction.UP.ordinal()][2] = new ImageIcon("resources/pacman/up/up_3.png");
        pacmanImages[Direction.UP.ordinal()][3] = new ImageIcon("resources/pacman/up/up_4.png");


        // down
        pacmanImages[Direction.DOWN.ordinal()][0] = new ImageIcon("resources/pacman/down/down_1.png");
        pacmanImages[Direction.DOWN.ordinal()][1] = new ImageIcon("resources/pacman/down/down_2.png");
        pacmanImages[Direction.DOWN.ordinal()][2] = new ImageIcon("resources/pacman/down/down_3.png");
        pacmanImages[Direction.DOWN.ordinal()][3] = new ImageIcon("resources/pacman/down/down_4.png");


        //left
        pacmanImages[Direction.LEFT.ordinal()][0] = new ImageIcon("resources/pacman/left/left_1.png");
        pacmanImages[Direction.LEFT.ordinal()][1] = new ImageIcon("resources/pacman/left/left_2.png");
        pacmanImages[Direction.LEFT.ordinal()][2] = new ImageIcon("resources/pacman/left/left_3.png");
        pacmanImages[Direction.LEFT.ordinal()][3] = new ImageIcon("resources/pacman/left/left_4.png");


        //right
        pacmanImages[Direction.RIGHT.ordinal()][0] = new ImageIcon("resources/pacman/right/right_1.png");
        pacmanImages[Direction.RIGHT.ordinal()][1] = new ImageIcon("resources/pacman/right/right_2.png");
        pacmanImages[Direction.RIGHT.ordinal()][2] = new ImageIcon("resources/pacman/right/right_3.png");
        pacmanImages[Direction.RIGHT.ordinal()][3] = new ImageIcon("resources/pacman/right/right_4.png");

    }

    public ImageIcon getCurrentIcon() {
        Direction currentDirection = pacmanModel.getDirection();
        int currentFrame = pacmanModel.getAnimationFrame();
        return pacmanImages[currentDirection.ordinal()][currentFrame];
    }

    public void pacmanFaceThread() {
        new Thread(() -> {
            while (true) {
                // Aktualizuj stan animacji Pacmana
                pacmanModel.updateAnimation();
                repaint();

                try {
                    Thread.sleep(300); // Ustaw odpowiednie opóźnienie
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
            }
        }).start();
    }
}

package model;

import view.PacmanView;

import java.awt.*;

public class PacmanModel extends Rectangle {
    private int pxX, pxY; // Aktualna pozycja Pacmana w px
    private PacmanView pacmanView; // referencja do obiektu Pacmanview ktora bedzie potrzebna do uzyskania wielkosci Pacmana.
    private Direction direction;
    private GameModel gameModel; // Referencja do modelu gry, aby sprawdzić kolizje
    private int animationFrame;
    private int speed;
    private volatile boolean isMoving;

    public PacmanModel(GameModel gameModel, int pxX, int pxY) {
        this.gameModel = gameModel;
        this.pxX = pxX;
        this.pxY = pxY;
        System.out.println("start x = " + pxX + " start y= " +pxY);
        this.isMoving = false;
        this.direction = Direction.LEFT; // Przykładowy początkowy kierunek
    }

    // Metoda do aktualizacji animacji
    public void updateAnimation() {
        animationFrame = (animationFrame + 1) % 4;
    }

    public void move(Direction direction, int speed) {
        this.speed = speed;
        this.direction = direction;

        int pxNewY = pxY;
        int pxNewX = pxX;

        if(isMoving) {
            switch (direction) {
                case UP:
                    pxNewY-=speed;
                    break;
                case DOWN:
                    pxNewY+=speed;
                    break;
                case LEFT:
                    pxNewX-=speed;
                    break;
                case RIGHT:
                    pxNewX+=speed;
                    break;
            }
            pxX = pxNewX;
            pxY = pxNewY;
            setLocation(pxX, pxY);
            System.out.println("pxX = " + pxX + " pxY = " + pxY);
        }
    }

    private boolean isMovePossible(int newX, int newY) {
        int cellWidth = gameModel.getGameTable().getCellWidth();
        int cellHeight = gameModel.getGameTable().getCellHeight();

        // Oblicz indeksy komórek dla nowej pozycji Pacmana
        int leftCol = newX / cellWidth;
        int rightCol = (newX + cellWidth - 1) / cellWidth;
        int topRow = newY / cellHeight;
        int bottomRow = (newY + cellHeight - 1) / cellHeight;

        // Sprawdź wszystkie komórki, które Pacman może częściowo zajmować
        for (int col = leftCol; col <= rightCol; col++) {
            for (int row = topRow; row <= bottomRow; row++) {
                if (gameModel.getCellType(row, col) != CellType.EMPTY) {
                    return false; // Przeszkoda znaleziona, ruch niemożliwy
                }
            }
        }
        return true; // Brak przeszkód, ruch możliwy
    }

    public boolean isMoving() {
        return isMoving;
    }

    public void setMoving(boolean state) {
        this.isMoving = state;
    }

    public Direction getDirection() {
        return direction;
    }

    public int getAnimationFrame() {
        return animationFrame;
    }

    public Point getPosition() {
        return new Point(this.pxX, this.pxY);
    }

    public void setPosition(int x, int y) {
        this.pxX = x;
        this.pxY = y;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public void setPacmanView(PacmanView pacmanView) {
        this.pacmanView = pacmanView;
    }

    public PacmanView getPacmanView() {
        return pacmanView;
    }

    public void setPxX(int newX) {
    }
}

Also I'm adding few screenshoots:

After I moved Pacman to the middle of window game i resized it and look where pacman is...

Thank you for any help...

I expect Pacman's position to update to the appropriate window dimensions so that it remains in the same window position relative to the previous size.