Используйте привязки клавиш, серьезно, это решит множество проблем, связанных с KeyListener.

Разделите и разделите свою логику. Каждая «сущность» должна быть автономной единицей работы. В вашем случае они должны как минимум содержать информацию об их цвете, расположении и размере.

Для простоты я начал с чего-то, что можно было просто покрасить...

public interface Entity {
    public void paint(Graphics2D g2d);
}

Теперь у вас может быть много разных interface, которые отражают это, которые можно рисовать, перемещать, контролировать, представлять эффекты или что-то еще, что вам нужно, - тогда ваши классы должны реализовывать нужные им interface. Затем ваш движок просто имеет дело с «концепциями», которые ему нужны — нужны все «раскрашиваемые» объекты, нужны все «подвижные» объекты и т. д., когда это необходимо.

Далее я создал концепцию «игрока». Игрок — это «раскрашиваемый» объект, но он может каким-то образом контролироваться игроком, поэтому он принимает текущее состояние «ввода» и обновляет себя на основе этих состояний (подробнее об этом позже).

public static class PlayerEntity implements Entity {
    
   protected static final int DELTA = 2;
    
    private Rectangle bounds = new Rectangle(0, 0, 35, 35);
    private Color fillColor;

    public PlayerEntity(Color fillColor, Point location) {
        this.fillColor = fillColor;
        this.bounds.setLocation(location);
    }

    public Color getFillColor() {
        return fillColor;
    }

    public Rectangle getBounds() {
        return bounds;
    }
    
    public Point getCenter() {
        return new Point((int)getBounds().getCenterX(), (int)getBounds().getCenterY());
    }
    
    public void update(Set<PlayerAction> actions, Dimension size) {
        Rectangle currentBounds = getBounds();
        int x = currentBounds.x;
        int y = currentBounds.y;
        
        if (actions.contains(PlayerAction.UP)) {
            y -= DELTA;
        }
        if (actions.contains(PlayerAction.DOWN)) {
            y += DELTA;
        }
        if (actions.contains(PlayerAction.LEFT)) {
            x -= DELTA;
        }
        if (actions.contains(PlayerAction.RIGHT)) {
            x += DELTA;
        }
        
        if (y < 0) {
            y = 0;
        }
        if (y + currentBounds.height > size.height) {
            y = size.height - currentBounds.height;
        }
        if (x < 0) {
            x = 0;
        }
        if (x + currentBounds.width > size.width) {
            x = size.width - currentBounds.width;
        }
        
        getBounds().setLocation(x, y);
    }

    @Override
    public void paint(Graphics2D g2d) {
        g2d.setColor(getFillColor());
        g2d.fill(getBounds());
    }
    
}

Для справки, PlayerAction представляет все допустимые действия, которые может выполнить игрок, для простоты я просто остановился на движении:

public enum PlayerAction {
    UP, DOWN, LEFT, RIGHT;
}

Затем я создал объект «монстр», в этом случае «монстр» всегда будет пытаться следовать за игроком, эта реализация в общих чертах основана на Java: переместите изображение к положению мыши

public static class MonsterEntity implements Entity {
    protected static final int DELTA = 1;

    private Rectangle bounds = new Rectangle(0, 0, 15, 15);
    private Color fillColor;

    public MonsterEntity(Color fillColor, Point location) {
        this.fillColor = fillColor;
        this.bounds.setLocation(location);
    }

    public Color getFillColor() {
        return fillColor;
    }

    public Rectangle getBounds() {
        return bounds;
    }
            
    public Point getCenter() {
        return new Point((int)getBounds().getCenterX(), (int)getBounds().getCenterY());
    }

    public void moveTowards(Point target) {
        Rectangle bounds = getBounds();
        Point center = getCenter();
        int xDelta = target.x < center.x ? -DELTA : DELTA;
        int yDelta = target.y < center.y ? -DELTA : DELTA;
        
        getBounds().setLocation(bounds.x + xDelta, bounds.y + yDelta);
    }

    @Override
    public void paint(Graphics2D g2d) {
        g2d.setColor(getFillColor());
        g2d.fill(getBounds());
    }
}

Монстр всегда пытается переместить свой центр в целевое место (которое в конечном итоге станет центром игрока).

Теперь здесь все усложняется.

Нам нужно:

• Визуализируемая поверхность, на которой мы можем нарисовать игрока и монстра(ов)
• Привязки ввода
• «Игровой цикл» для обновления состояния объектов и планирования перерисовки.

Для простоты я начал с JPanel, использовал Swing Timer и API привязки клавиш.

public class MainPane extends JPanel {
    
    // This represents the "input bindings", these represent
    // abstract actions which can be applied to the player
    // or game state.
    private enum InputKey {
        PRESSED_UP, PRESSED_DOWN, PRESSED_LEFT, PRESSED_RIGHT,
        RELEASED_UP, RELEASED_DOWN, RELEASED_LEFT, RELEASED_RIGHT;
        
        public KeyStroke getKeyStroke() {
            switch (this) {
                case PRESSED_UP: return KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0, false);
                case PRESSED_DOWN: return KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0, false);
                case PRESSED_LEFT: return KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0, false);
                case PRESSED_RIGHT: return KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0, false);
                case RELEASED_UP: return KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0, true);
                case RELEASED_DOWN: return KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0, true);
                case RELEASED_LEFT: return KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0, true);
                case RELEASED_RIGHT: return KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0, true);
            }
            return null;
        }
    }
    
    private PlayerEntity playerEntity;
    private MonsterEntity monsterEntity;
    private Timer timer;
    
    private Set<PlayerAction> actions = new HashSet<PlayerAction>();
    
    public MainPane() {
        InputMap inputMap = getInputMap(WHEN_IN_FOCUSED_WINDOW);
        ActionMap actionMap = getActionMap();
        
        inputMap.put(InputKey.PRESSED_UP.getKeyStroke(), InputKey.PRESSED_UP);
        inputMap.put(InputKey.PRESSED_DOWN.getKeyStroke(), InputKey.PRESSED_DOWN);
        inputMap.put(InputKey.PRESSED_LEFT.getKeyStroke(), InputKey.PRESSED_LEFT);
        inputMap.put(InputKey.PRESSED_RIGHT.getKeyStroke(), InputKey.PRESSED_RIGHT);
        inputMap.put(InputKey.RELEASED_UP.getKeyStroke(), InputKey.RELEASED_UP);
        inputMap.put(InputKey.RELEASED_DOWN.getKeyStroke(), InputKey.RELEASED_DOWN);
        inputMap.put(InputKey.RELEASED_LEFT.getKeyStroke(), InputKey.RELEASED_LEFT);
        inputMap.put(InputKey.RELEASED_RIGHT.getKeyStroke(), InputKey.RELEASED_RIGHT);
        
        actionMap.put(InputKey.PRESSED_UP, new MoveAction(actions, PlayerAction.UP, true));
        actionMap.put(InputKey.PRESSED_DOWN, new MoveAction(actions, PlayerAction.DOWN, true));
        actionMap.put(InputKey.PRESSED_LEFT, new MoveAction(actions, PlayerAction.LEFT, true));
        actionMap.put(InputKey.PRESSED_RIGHT, new MoveAction(actions, PlayerAction.RIGHT, true));
        actionMap.put(InputKey.RELEASED_UP, new MoveAction(actions, PlayerAction.UP, false));
        actionMap.put(InputKey.RELEASED_DOWN, new MoveAction(actions, PlayerAction.DOWN, false));
        actionMap.put(InputKey.RELEASED_LEFT, new MoveAction(actions, PlayerAction.LEFT, false));
        actionMap.put(InputKey.RELEASED_RIGHT, new MoveAction(actions, PlayerAction.RIGHT, false));
        
        Dimension size = getPreferredSize();
        Point center = new Point((size.width - 35) / 2, (size.height - 35) / 2);
        
        playerEntity = new PlayerEntity(Color.BLUE, center);
        monsterEntity = new MonsterEntity(Color.RED, new Point(size.width - 15, size.height - 15));
    }

    @Override
    public void addNotify() {
        super.addNotify();
        if (timer != null) {
            timer.stop();
        }
        timer = new Timer(5, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                performTick();
            }
        });
        timer.start();
    }

    @Override
    public void removeNotify() {
        super.removeNotify();
        if (timer != null) {
            timer.stop();
        }
    }

    @Override
    public Dimension getPreferredSize() {
        return new Dimension(400, 400);
    }
    
    protected void performTick() {
        playerEntity.update(actions, getSize());
        monsterEntity.moveTowards(playerEntity.getCenter());
        repaint();
    }
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();
        playerEntity.paint(g2d);
        monsterEntity.paint(g2d);
        g2d.dispose();
    }        
}

Движение (или ввод) контролируется через API привязки клавиш, это запускает MoveAction, который обновляет централизованный репозиторий состояний (который затем передается в PlayerEntity, чтобы он соответствующим образом применял состояние).

Для простоты я использовал только один Action, но вы можете сделать пару, один из которых представляет «нажать/активировать» или «отпустить/деактивировать».

public class MoveAction extends AbstractAction {
    
    private Set<PlayerAction> actions;
    private PlayerAction action;
    private boolean activate;

    public MoveAction(Set<PlayerAction> directions, PlayerAction direction, boolean activate) {
        this.actions = directions;
        this.action = direction;
        this.activate = activate;
    }
    
    @Override
    public void actionPerformed(ActionEvent e) {
        if (activate) {
            actions.add(action);
        } else {
            actions.remove(action);
        }
    }
    
}

См. Как использовать действия для получения более подробной информации о действиях.

Но зачем следовать этому рабочему процессу?!

1. Он разделяет и децентрализует многие рабочие процессы. На самом деле, если вы действительно хотите, вы также можете разделить рабочие процессы Timer и «рисования» на отдельные классы, еще больше разделив классы.
2. Привязки клавиш решают все проблемы, связанные с KeyListener странностями. Это также разделяет ввод — хотите добавить сенсорные элементы управления/кнопки, не беспокойтесь, это делается с помощью Actions. Хотите добавить джойстик/контроллеры, не беспокойтесь, это делается через Actions.

Хотите больше монстров?

Изменение:

private MonsterEntity monsterEntity;

к:

private List<MonsterEntity> monsterEntitys = new ArrayList<>(32);

Изменение:

monsterEntity = new MonsterEntity(Color.RED, new Point(size.width - 15, size.height - 15));

к:

monsterEntitys.add(new MonsterEntity(Color.RED, new Point(size.width - 15, size.height - 15)));
monsterEntitys.add(new MonsterEntity(Color.RED, new Point(0, 0)));
monsterEntitys.add(new MonsterEntity(Color.RED, new Point(size.width - 15, 0)));
monsterEntitys.add(new MonsterEntity(Color.RED, new Point(0, size.height - 15)));

Изменение:

monsterEntity.paint(g2d);

к:

for (MonsterEntity entity : monsterEntitys) {
    entity.paint(g2d);
}

И теперь у вас есть больше монстров! Получайте удовольствие от этого!

Запускаемый пример...

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.util.HashSet;
import java.util.Set;
import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
import javax.swing.Timer;

public class Main {
    public static void main(String[] args) {
        new Main();
    }

    public Main() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                JFrame frame = new JFrame();
                frame.add(new MainPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public enum PlayerAction {
        UP, DOWN, LEFT, RIGHT;
    }

    public class MainPane extends JPanel {

        private enum InputKey {
            PRESSED_UP, PRESSED_DOWN, PRESSED_LEFT, PRESSED_RIGHT,
            RELEASED_UP, RELEASED_DOWN, RELEASED_LEFT, RELEASED_RIGHT;

            public KeyStroke getKeyStroke() {
                switch (this) {
                    case PRESSED_UP: return KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0, false);
                    case PRESSED_DOWN: return KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0, false);
                    case PRESSED_LEFT: return KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0, false);
                    case PRESSED_RIGHT: return KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0, false);
                    case RELEASED_UP: return KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0, true);
                    case RELEASED_DOWN: return KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0, true);
                    case RELEASED_LEFT: return KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0, true);
                    case RELEASED_RIGHT: return KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0, true);
                }
                return null;
            }
        }

        private PlayerEntity playerEntity;
        private MonsterEntity monsterEntity;
        private Timer timer;

        private Set<PlayerAction> actions = new HashSet<PlayerAction>();

        public MainPane() {
            InputMap inputMap = getInputMap(WHEN_IN_FOCUSED_WINDOW);
            ActionMap actionMap = getActionMap();

            inputMap.put(InputKey.PRESSED_UP.getKeyStroke(), InputKey.PRESSED_UP);
            inputMap.put(InputKey.PRESSED_DOWN.getKeyStroke(), InputKey.PRESSED_DOWN);
            inputMap.put(InputKey.PRESSED_LEFT.getKeyStroke(), InputKey.PRESSED_LEFT);
            inputMap.put(InputKey.PRESSED_RIGHT.getKeyStroke(), InputKey.PRESSED_RIGHT);
            inputMap.put(InputKey.RELEASED_UP.getKeyStroke(), InputKey.RELEASED_UP);
            inputMap.put(InputKey.RELEASED_DOWN.getKeyStroke(), InputKey.RELEASED_DOWN);
            inputMap.put(InputKey.RELEASED_LEFT.getKeyStroke(), InputKey.RELEASED_LEFT);
            inputMap.put(InputKey.RELEASED_RIGHT.getKeyStroke(), InputKey.RELEASED_RIGHT);

            actionMap.put(InputKey.PRESSED_UP, new MoveAction(actions, PlayerAction.UP, true));
            actionMap.put(InputKey.PRESSED_DOWN, new MoveAction(actions, PlayerAction.DOWN, true));
            actionMap.put(InputKey.PRESSED_LEFT, new MoveAction(actions, PlayerAction.LEFT, true));
            actionMap.put(InputKey.PRESSED_RIGHT, new MoveAction(actions, PlayerAction.RIGHT, true));
            actionMap.put(InputKey.RELEASED_UP, new MoveAction(actions, PlayerAction.UP, false));
            actionMap.put(InputKey.RELEASED_DOWN, new MoveAction(actions, PlayerAction.DOWN, false));
            actionMap.put(InputKey.RELEASED_LEFT, new MoveAction(actions, PlayerAction.LEFT, false));
            actionMap.put(InputKey.RELEASED_RIGHT, new MoveAction(actions, PlayerAction.RIGHT, false));

            Dimension size = getPreferredSize();
            Point center = new Point((size.width - 35) / 2, (size.height - 35) / 2);

            playerEntity = new PlayerEntity(Color.BLUE, center);
            monsterEntity = new MonsterEntity(Color.RED, new Point(size.width - 15, size.height - 15));
        }

        @Override
        public void addNotify() {
            super.addNotify();
            if (timer != null) {
                timer.stop();
            }
            timer = new Timer(5, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    performTick();
                }
            });
            timer.start();
        }

        @Override
        public void removeNotify() {
            super.removeNotify();
            if (timer != null) {
                timer.stop();
            }
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(400, 400);
        }

        protected void performTick() {
            playerEntity.update(actions, getSize());
            monsterEntity.moveTowards(playerEntity.getCenter());
            repaint();
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            playerEntity.paint(g2d);
            monsterEntity.paint(g2d);
            g2d.dispose();
        }        
    }

    public class MoveAction extends AbstractAction {

        private Set<PlayerAction> actions;
        private PlayerAction action;
        private boolean activate;

        public MoveAction(Set<PlayerAction> directions, PlayerAction direction, boolean activate) {
            this.actions = directions;
            this.action = direction;
            this.activate = activate;
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            if (activate) {
                actions.add(action);
            } else {
                actions.remove(action);
            }
        }

    }

    public interface Entity {
        public void paint(Graphics2D g2d);
    }

    public static class MonsterEntity implements Entity {
        protected static final int DELTA = 1;

        private Rectangle bounds = new Rectangle(0, 0, 15, 15);
        private Color fillColor;

        public MonsterEntity(Color fillColor, Point location) {
            this.fillColor = fillColor;
            this.bounds.setLocation(location);
        }

        public Color getFillColor() {
            return fillColor;
        }

        public Rectangle getBounds() {
            return bounds;
        }

        public Point getCenter() {
            return new Point((int)getBounds().getCenterX(), (int)getBounds().getCenterY());
        }

        public void moveTowards(Point target) {
            Rectangle bounds = getBounds();
            Point center = getCenter();
            int xDelta = target.x < center.x ? -DELTA : DELTA;
            int yDelta = target.y < center.y ? -DELTA : DELTA;

            getBounds().setLocation(bounds.x + xDelta, bounds.y + yDelta);
        }

        @Override
        public void paint(Graphics2D g2d) {
            g2d.setColor(getFillColor());
            g2d.fill(getBounds());
        }
    }

    public static class PlayerEntity implements Entity {

       protected static final int DELTA = 2;

        private Rectangle bounds = new Rectangle(0, 0, 35, 35);
        private Color fillColor;

        public PlayerEntity(Color fillColor, Point location) {
            this.fillColor = fillColor;
            this.bounds.setLocation(location);
        }

        public Color getFillColor() {
            return fillColor;
        }

        public Rectangle getBounds() {
            return bounds;
        }

        public Point getCenter() {
            return new Point((int)getBounds().getCenterX(), (int)getBounds().getCenterY());
        }

        public void update(Set<PlayerAction> actions, Dimension size) {
            Rectangle currentBounds = getBounds();
            int x = currentBounds.x;
            int y = currentBounds.y;

            if (actions.contains(PlayerAction.UP)) {
                y -= DELTA;
            }
            if (actions.contains(PlayerAction.DOWN)) {
                y += DELTA;
            }
            if (actions.contains(PlayerAction.LEFT)) {
                x -= DELTA;
            }
            if (actions.contains(PlayerAction.RIGHT)) {
                x += DELTA;
            }

            if (y < 0) {
                y = 0;
            }
            if (y + currentBounds.height > size.height) {
                y = size.height - currentBounds.height;
            }
            if (x < 0) {
                x = 0;
            }
            if (x + currentBounds.width > size.width) {
                x = size.width - currentBounds.width;
            }

            getBounds().setLocation(x, y);
        }

        @Override
        public void paint(Graphics2D g2d) {
            g2d.setColor(getFillColor());
            g2d.fill(getBounds());
        }

    }
}

Другие соображения...

Прямо сейчас скорость/дельта на самом деле очень высоки. Я бы подумал об использовании Shape API, используя такие вещи, как Point2D и Rectangle2D, которые предоставляют свойства на основе double вместо int, что привело бы к уменьшению дельта-значений и замедлению объектов.

См. Работа с геометрией для более подробной информации.