Game Development Loop, Logic and Collision detection Java Swing 2D

import java.awt.BorderLayout;
    import java.awt.Color;
    import java.awt.Dimension;
    import java.awt.Graphics;
    import java.awt.Graphics2D;
    import java.awt.RenderingHints;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.KeyEvent;
    import java.awt.geom.Rectangle2D;
    import java.awt.image.BufferedImage;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicBoolean;
    import javax.swing.AbstractAction;
    import javax.swing.JButton;
    import javax.swing.JComponent;
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.KeyStroke;
    import javax.swing.SwingUtilities;
    import javax.swing.UIManager;
    import javax.swing.UIManager.LookAndFeelInfo;
    import javax.swing.UnsupportedLookAndFeelException;
    
    public class GameTest {
    
        public static final int HERTZ = 60;
        public static final int WIDTH = 800, HEIGHT = 600;
        public static final Dimension STANDARD_IMAGE_SCREEN_SIZE = new Dimension(800, 600);
        private ImageScaler is = new ImageScaler(STANDARD_IMAGE_SCREEN_SIZE, new Dimension(WIDTH, HEIGHT));//create instance to allow creating of image sizes for current screen size and width
    
        public GameTest() {
            createAndShowGui();
        }
    
        //code starts here
        public static void main(String[] args) {
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    try {
                        for (LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
                            if ("Nimbus".equals(info.getName())) {
                                UIManager.setLookAndFeel(info.getClassName());
                                break;
                            }
                        }
                    } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException e) {
                        // If Nimbus is not available, you can set the GUI to another look and feel.
                    }
    
                    new GameTest();//create an instance which incudes GUI etc
                }
            });
        }
    
        private void createAndShowGui() {
            JFrame frame = new JFrame(GameTest.class.getSimpleName());
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setResizable(false);
    
            final GamePanel gamePanel = new GamePanel(HERTZ, WIDTH, HEIGHT);
    
            JPanel buttonPanel = new JPanel();
    
            //create buttons to control game loop start pause/resume and stop
            final JButton startButton = new JButton("Start");
    
            final JButton pauseButton = new JButton("Pause");
            pauseButton.setEnabled(false);
    
            final JButton stopButton = new JButton("Stop");
            stopButton.setEnabled(false);
    
            //add listeners to buttons 
            startButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    //clear enitites currently in array
                    gamePanel.clearGameObjects();
                    //create test images for game object
                    ArrayList<BufferedImage> images = new ArrayList<>();
                    ArrayList<Long> timings = new ArrayList<>();
                    images.add(createColouredImage(Color.RED, 100, 100, false));
                    timings.add(300l);
                    images.add(createColouredImage(Color.BLACK, 100, 100, false));
                    timings.add(300l);
                    images.add(createColouredImage(Color.GREEN, 100, 100, false));
                    timings.add(300l);
    
                    //create arraylist of images scaled for the current screen size
                    ArrayList<BufferedImage> scaledImages = is.scaleImages(images);
    
                    //get starting position according to current screen size
                    //the position 0f 200,300 is on standrad screen size of 800,600
                    int startingXPlayer1 = (int) (200 * is.getWidthScaleFactor());
                    int startingYPlayer1 = (int) (300 * is.getHeightScaleFactor());
    
                    //create player 1 game onject which can be controlled by W,S,A,D and SPACE to shoot
                    final GameObject player1GameObject = new GameObject(startingXPlayer1, startingYPlayer1, scaledImages, timings, GameObject.RIGHT_FACING, gamePanel.getWidth(), gamePanel.getHeight());
    
                    images.clear();//clear arrays so we can add images for another just saving time
                    timings.clear();
    
                    images.add(createColouredImage(Color.CYAN, 100, 100, false));
                    timings.add(500l);//show cyan for 500 milis
                    images.add(createColouredImage(Color.YELLOW, 100, 100, false));
                    timings.add(1500l);//show yellow for 500 milis
    
                    //create arraylist of images scaled for the current screen size
                    scaledImages = is.scaleImages(images);
    
                    //get starting position according to current screen size
                    //the position 0f 400,100 is on standrad screen size of 800,600
                    int startingXPlayer2 = (int) (400 * is.getWidthScaleFactor());
                    int startingYPlayer2 = (int) (100 * is.getHeightScaleFactor());
    
                    final GameObject player2GameObject = new GameObject(startingXPlayer2, startingYPlayer2, scaledImages, timings, GameObject.LEFT_FACING, gamePanel.getWidth(), gamePanel.getHeight());
    
                    //add gameobjetcs to the gamepanel
                    gamePanel.addGameObject(player1GameObject);
                    gamePanel.addGameObject(player2GameObject);
    
                    GameKeyBindings gameKeyBindings = new GameKeyBindings(gamePanel, player1GameObject, player2GameObject);
    
                    gamePanel.start();
    
                    startButton.setEnabled(false);
                    pauseButton.setEnabled(true);
                    stopButton.setEnabled(true);
                }
            });
    
            pauseButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    //checks if the game is paused or not and reacts by either resuming or pausing the game
                    if (gamePanel.isPaused()) {
                        gamePanel.resume();
                    } else {
                        gamePanel.pause();
                    }
                    if (pauseButton.getText().equals("Pause")) {
                        pauseButton.setText("Resume");
                    } else {
                        pauseButton.setText("Pause");
                        gamePanel.requestFocusInWindow();//button might have focus
                    }
                }
            });
    
            stopButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    gamePanel.stop();
                    /* 
                     //if we want enitites to be cleared and a blank panel shown
                     gp.clearGameObjects();
                     gp.repaint(); 
                     */
                    if (!pauseButton.getText().equals("Pause")) {
                        pauseButton.setText("Pause");
                    }
                    startButton.setEnabled(true);
                    pauseButton.setEnabled(false);
                    stopButton.setEnabled(false);
                }
            });
    
    
            //add buttons to panel
            buttonPanel.add(startButton);
            buttonPanel.add(pauseButton);
            buttonPanel.add(stopButton);
            //add game panel and button panel to jframe
            frame.add(gamePanel, BorderLayout.CENTER);
            frame.add(buttonPanel, BorderLayout.SOUTH);
    
            frame.pack();
            frame.setVisible(true);
        }
    
        public static BufferedImage createColouredImage(Color color, int w, int h, boolean circular) {
            BufferedImage img = new BufferedImage(w, h, BufferedImage.TRANSLUCENT);
            Graphics2D g2 = img.createGraphics();
            GamePanel.applyRenderHints(g2);
            g2.setColor(color);
            if (!circular) {
                g2.fillRect(0, 0, img.getWidth(), img.getHeight());
            } else {
                g2.fillOval(0, 0, w, h);
            }
            g2.dispose();
            return img;
        }
    }
    
    class GameKeyBindings {
    
        public GameKeyBindings(final GamePanel gp, final GameObject player1GameObject) {
    
            KeyBinding.putKeyBindingOnPressAndRelease(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_D, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player1GameObject.RIGHT = true;
                }
            }, "D pressed", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player1GameObject.RIGHT = false;
                }
            }, "D released");
    
            KeyBinding.putKeyBindingOnPressAndRelease(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_A, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player1GameObject.LEFT = true;
                }
            }, "A pressed", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player1GameObject.LEFT = false;
                }
            }, "A released");
    
            KeyBinding.putKeyBindingOnPressAndRelease(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_W, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player1GameObject.UP = true;
                }
            }, "W pressed", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player1GameObject.UP = false;
                }
            }, "W released");
            KeyBinding.putKeyBindingOnPressAndRelease(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_S, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player1GameObject.DOWN = true;
                }
            }, "S pressed", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player1GameObject.DOWN = false;
                }
            }, "S released");
    
            final ArrayList<BufferedImage> images = new ArrayList<>();
            final ArrayList<Long> timings = new ArrayList<>();
            images.add(GameTest.createColouredImage(Color.darkGray.brighter(), 10, 10, true));
            timings.add(300l);
            KeyBinding.putKeyBindingOnPress(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_SPACE, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    Bullet bullet = new Bullet((int) (player1GameObject.getX() + player1GameObject.getHeight() / 2), (int) (player1GameObject.getY() + player1GameObject.getWidth() / 2), images, timings, GameObject.RIGHT_FACING, gp.getWidth(), gp.getHeight(), player1GameObject, gp);
    
                    gp.addGameObject(bullet);//add the bullet to the List of GameObjects that will be drawn on next screen paint
                }
            }, "Space pressed");
        }
    
        GameKeyBindings(final GamePanel gp, GameObject player1GameObject, final GameObject player2GameObject) {
            this(gp, player1GameObject);
    
            KeyBinding.putKeyBindingOnPressAndRelease(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_RIGHT, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player2GameObject.RIGHT = true;
                }
            }, "right pressed", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player2GameObject.RIGHT = false;
                }
            }, "right released");
    
            KeyBinding.putKeyBindingOnPressAndRelease(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_LEFT, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player2GameObject.LEFT = true;
                }
            }, "left pressed", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player2GameObject.LEFT = false;
                }
            }, "left released");
    
            KeyBinding.putKeyBindingOnPressAndRelease(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_UP, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player2GameObject.UP = true;
                }
            }, "up pressed", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player2GameObject.UP = false;
                }
            }, "up released");
            KeyBinding.putKeyBindingOnPressAndRelease(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_DOWN, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player2GameObject.DOWN = true;
                }
            }, "down pressed", new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    player2GameObject.DOWN = false;
                }
            }, "down released");
    
            final ArrayList<BufferedImage> images = new ArrayList<>();
            final ArrayList<Long> timings = new ArrayList<>();
            images.add(GameTest.createColouredImage(Color.MAGENTA, 10, 10, true));
            timings.add(0l);
    
    
            KeyBinding.putKeyBindingOnPress(gp, KeyBinding.WHEN_IN_FOCUSED_WINDOW, KeyEvent.VK_ENTER, new AbstractAction() {
                @Override
                public void actionPerformed(ActionEvent ae) {
                    Bullet bullet = new Bullet((int) (player2GameObject.getX() + player2GameObject.getHeight() / 2), (int) (player2GameObject.getY() + player2GameObject.getWidth() / 2), images, timings, GameObject.RIGHT_FACING, gp.getWidth(), gp.getHeight(), player2GameObject, gp);
    
                    gp.addGameObject(bullet);//add the bullet to the List of GameObjects that will be drawn on next screen paint
                }
            }, "Enter pressed");
        }
    }
    
    class KeyBinding {
    
        private final JComponent container;
        private final int inputMap;
        public static final int WHEN_IN_FOCUSED_WINDOW = JComponent.WHEN_IN_FOCUSED_WINDOW,
                WHEN_FOCUSED = JComponent.WHEN_FOCUSED,
                WHEN_ANCESTOR_OF_FOCUSED_COMPONENT = JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT;
    
        public KeyBinding(JComponent container, int inputMap) {
            this.container = container;
            this.inputMap = inputMap;
        }
    
        public void addKeyBinding(int key, boolean onRelease, AbstractAction keybindingAction, String description) {
            putKeyBinding(container, inputMap, key, onRelease, keybindingAction, description);
        }
    
        public void addKeyBindingOnPress(int key, AbstractAction keybindingAction, String description) {
            putKeyBinding(container, inputMap, key, false, keybindingAction, description);
        }
    
        public void addKeyBindingOnRelease(int key, AbstractAction keybindingAction, String description) {
            putKeyBinding(container, inputMap, key, true, keybindingAction, description);
        }
    
        public void addKeyBindingOnPressAndRelease(int key, AbstractAction onPressAction, String onPressDesc, AbstractAction onReleaseAction, String onReleaseDesc) {
            putKeyBinding(container, inputMap, key, false, onPressAction, onPressDesc);
            putKeyBinding(container, inputMap, key, true, onReleaseAction, onReleaseDesc);
        }
    
        public static void putKeyBinding(JComponent container, int inputMap, int key, boolean onRelease, AbstractAction keybindingAction, String description) {
            container.getInputMap(inputMap).put(KeyStroke.getKeyStroke(key, 0, onRelease), description);
            container.getActionMap().put(description, keybindingAction);
        }
    
        public static void putKeyBindingOnPress(JComponent container, int inputMap, int key, AbstractAction keybindingAction, String description) {
            container.getInputMap(inputMap).put(KeyStroke.getKeyStroke(key, 0, false), description);
            container.getActionMap().put(description, keybindingAction);
        }
    
        public static void putKeyBindingOnRelease(JComponent container, int inputMap, int key, AbstractAction keybindingAction, String description) {
            container.getInputMap(inputMap).put(KeyStroke.getKeyStroke(key, 0, true), description);
            container.getActionMap().put(description, keybindingAction);
        }
    
        public static void putKeyBindingOnPressAndRelease(JComponent container, int inputMap, int key, AbstractAction onPressAction, String onPressDesc, AbstractAction onReleaseAction, String onReleaseDesc) {
            putKeyBinding(container, inputMap, key, false, onPressAction, onPressDesc);
            putKeyBinding(container, inputMap, key, true, onReleaseAction, onReleaseDesc);
        }
    }
    
    class GamePanel extends JPanel {
    
        private final static RenderingHints textRenderHints = new RenderingHints(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
        private final static RenderingHints imageRenderHints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        private final static RenderingHints colorRenderHints = new RenderingHints(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
        private final static RenderingHints interpolationRenderHints = new RenderingHints(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        private final static RenderingHints renderHints = new RenderingHints(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        private GameLoop gameLoop;
        private int width, height;
        protected final List<GameObject> gameObjects = Collections.synchronizedList(new ArrayList<GameObject>());
    
        public GamePanel(int fps, int w, int h) {
            super(true);
            width = w;
            height = h;
            setIgnoreRepaint(true);//we will do the repainting
    
            gameLoop = new GameLoop(fps) {
                @Override
                void update(long elapsedTime) {//updates GameObject movement and Animation
                    updateGameObjects(elapsedTime);
                }
    
                @Override
                void draw() {//repaints the screen
                    repaint();
                }
    
                @Override
                void checkCollisions() {//collisons are checked after draw() is called
                    //do GameObject collision checks here
                    ArrayList<GameObject> gameObs = new ArrayList<>(gameObjects);
                    for (GameObject go : gameObs) {//iterate through all game objects
                        if (go instanceof Bullet) {//check if its a bullet
                            //get Bullet instance and its owner
                            Bullet bullet = (Bullet) go;
                            GameObject bulletOwner = bullet.getOwner();
    
                            for (GameObject go2 : gameObs) {//go trhough each object again
                                if (!go2.equals(bullet)) {//make sure we are not checking the bullet against itself
                                    if (bullet.intersects(go2) && !go2.equals(bulletOwner)) {//check if the bullets intersects any other object besides its owner
                                        System.out.println("A bullet hit a GameObject other than its owner");
                                        //bullet has hit get rid of it
                                        bullet.setVisible(false);
                                        removeGameObject(bullet);
                                    }
                                }
                            }
                        } else {//its not a Nullte thus must be a GameObject
                            for (GameObject go2 : gameObs) {//go through each GameObject again
                                if (!go.equals(go2)) {//make sure its not checking itself
                                    if (!(go2 instanceof Bullet)) {//make sure we dont chec bulltes as this has been done above
                                        if (go.intersects(go2)) {//check if the 2 gameobjects are intersecting each other
                                            System.out.println("A GameObject intersected another");
                                        }
                                    }
                                }
                            }
                        }
                    }
    
                }
            };
        }
    
        public void addGameObject(GameObject go) {
            gameObjects.add(go);
        }
    
        public void removeGameObject(GameObject go) {
            gameObjects.remove(go);
        }
    
        public void clearGameObjects() {
            gameObjects.clear();
        }
    
        @Override
        public Dimension getPreferredSize() {
            return new Dimension(width, height);
        }
    
        private void updateGameObjects(long elapsedTime) {
            ArrayList<GameObject> gameObs = new ArrayList<>(gameObjects);
            for (GameObject gameObject : gameObs) {
                if (gameObject.isVisible()) {
                    //update the movement and image of the gameobject
                    gameObject.update(elapsedTime);//updates the images i.e if its more than a single imag it will check to see if enough time has passed to make a change
                    gameObject.move();
                }
            }
        }
    
        @Override
        protected void paintComponent(Graphics grphcs) {
            super.paintComponent(grphcs);
    
            Graphics2D g2d = (Graphics2D) grphcs;
    
            applyRenderHints(g2d);
    
            //draw background
            g2d.setColor(Color.WHITE);
            g2d.fillRect(0, 0, getWidth(), getHeight());
    
            //draw all GameObjects to the screen
            ArrayList<GameObject> gameObs = new ArrayList<>(gameObjects);
            for (GameObject gameObject : gameObs) {
                if (gameObject.isVisible()) {
                    //draw the object to JPanel
                    g2d.drawImage(gameObject.getCurrentImage(), (int) gameObject.getX(), (int) gameObject.getY(), null);
                }
            }
        }
    
        public void start() {
            gameLoop.start();
        }
    
        public void pause() {
            gameLoop.pause();
        }
    
        public void resume() {
            gameLoop.resume();
        }
    
        public void stop() {
            gameLoop.stop();
        }
    
        public boolean isPaused() {
            return gameLoop.isPaused();
        }
    
        public boolean isRunning() {
            return gameLoop.isRunning();
        }
    
        public static void applyRenderHints(Graphics2D g2d) {
            g2d.setRenderingHints(textRenderHints);
            g2d.setRenderingHints(imageRenderHints);
            g2d.setRenderingHints(colorRenderHints);
            g2d.setRenderingHints(interpolationRenderHints);
            g2d.setRenderingHints(renderHints);
        }
    }
    
    class Bullet extends GameObject {
    
        private final GameObject owner;
        private final GamePanel gp;
    
        public Bullet(int x, int y, ArrayList<BufferedImage> frames, ArrayList<Long> timings, int pos, int conW, int conH, final GameObject owner, GamePanel gp) {
            super(x, y, frames, timings, pos, conW, conH);
            this.owner = owner;
            //add the bullet to the List of GameObjects that will be drawn on next screen paint
            setSpeed(DEFAULT_SPEED * 2); // setSpeed(getSpeed() * 2);
            //check which way the game object is facing and make bullet go accrodingly
            if (owner.getPosition() == GameObject.LEFT_FACING) {
                LEFT = true;
            } else if (owner.getPosition() == GameObject.RIGHT_FACING) {
                RIGHT = true;
            }
            this.gp = gp;
        }
    
        public GameObject getOwner() {
            return owner;
        }
    
        @Override
        public void move() {
            if ((rectangle.x - speed) <= 0) {
                setVisible(false);
                gp.removeGameObject(this);
            } else if (LEFT) {
                position = LEFT_FACING;
                rectangle.x -= speed;
            }
            if ((rectangle.x + speed) + getWidth() >= conW) {
                setVisible(false);
                gp.removeGameObject(this);
            } else if (RIGHT) {
                position = RIGHT_FACING;
                rectangle.x += speed;
            }
            if ((rectangle.y - speed) <= 0) {
                setVisible(false);
                gp.removeGameObject(this);
            } else if (UP) {
                rectangle.y -= speed;
            }
            if ((rectangle.y + speed) + getHeight() >= conH) {
                setVisible(false);
                gp.removeGameObject(this);
            } else if (DOWN) {
                rectangle.y += speed;
            }
        }
    }
    
    class ImageScaler {
    
        private final Dimension origScreenSize;
        private final Dimension newScreenSize;
    
        public ImageScaler(Dimension origScreenSize, Dimension newScreenSize) {
            this.origScreenSize = origScreenSize;
            this.newScreenSize = newScreenSize;
        }
    
        public double getWidthScaleFactor() {
            return (double) newScreenSize.width / origScreenSize.width;
        }
    
        public double getHeightScaleFactor() {
            return (double) newScreenSize.height / origScreenSize.height;
        }
    
        public BufferedImage scaleImage(BufferedImage img) {
            int width = (int) (img.getWidth() * getWidthScaleFactor());
            int height = (int) (img.getHeight() * getHeightScaleFactor());
            return scaleImage(img, width, height);
        }
    
        public ArrayList<BufferedImage> scaleImages(ArrayList<BufferedImage> images) {
            ArrayList<BufferedImage> imgs = new ArrayList<>();
            for (BufferedImage bImg : images) {
                int width = (int) (bImg.getWidth() * getWidthScaleFactor());
                int height = (int) (bImg.getHeight() * getHeightScaleFactor());
                imgs.add(ImageScaler.scaleImage(bImg, width, height));
            }
            return imgs;
        }
    
        public static BufferedImage scaleImage(BufferedImage bimg, int width, int height) {
            BufferedImage bi;
            try {
                bi = new BufferedImage(width, height, BufferedImage.TRANSLUCENT);
                Graphics2D g2d = (Graphics2D) bi.createGraphics();
                GamePanel.applyRenderHints(g2d);
                g2d.drawImage(bimg, 0, 0, width, height, null);
            } catch (Exception e) {
                return null;
            }
            return bi;
        }
    }
    
    class GameObject extends Animator {
    
        protected Rectangle2D.Double rectangle;
        protected int speed, position;
        private boolean visible;
        public boolean LEFT, RIGHT, UP, DOWN;
        //used to keep track of the actual image direction 
        public final static int LEFT_FACING = -1, RIGHT_FACING = 1, DEFAULT_SPEED = 5;
        protected final int conW, conH;
    
        public GameObject(int x, int y, ArrayList<BufferedImage> frames, ArrayList<Long> timings, int pos, int conW, int conH) {
            super(frames, timings);
            UP = false;
            DOWN = false;
            LEFT = false;
            RIGHT = false;
            visible = true;
            speed = DEFAULT_SPEED;
            position = pos;
            rectangle = new Rectangle2D.Double(x, y, getCurrentImage().getWidth(), getCurrentImage().getHeight());
            this.conW = conW;
            this.conH = conH;
        }
    
        @Override
        public void update(long elapsedTime) {
            super.update(elapsedTime);
            getWidth();//set the rectangles height accordingly after image update
            getHeight();//set rectangles height accordingle after update
        }
    
        public void setX(double x) {
            rectangle.x = x;
        }
    
        public void setY(double y) {
            rectangle.y = y;
        }
    
        public void setWidth(double width) {
            rectangle.width = width;
        }
    
        public void setHeight(double height) {
            rectangle.height = height;
        }
    
        public double getX() {
            return rectangle.x;
        }
    
        public double getY() {
            return rectangle.y;
        }
    
        public double getWidth() {
            if (getCurrentImage() == null) {//there might be no image (which is unwanted ofcourse but  we must not get NPE so we check for null and return 0
                return rectangle.width = 0;
            }
    
            return rectangle.width = getCurrentImage().getWidth();
        }
    
        public double getHeight() {
            if (getCurrentImage() == null) {
                return rectangle.height = 0;
            }
            return rectangle.height = getCurrentImage().getHeight();
        }
    
        public void setSpeed(int s) {
            speed = s;
        }
    
        public int getSpeed() {
            return speed;
        }
    
        public boolean isVisible() {
            return visible;
        }
    
        public void setVisible(boolean v) {
            visible = v;
        }
    
        public void move() {
            if (LEFT && (rectangle.x - speed) >= 0) {
                position = LEFT_FACING;
                rectangle.x -= speed;
            }
            if (RIGHT && (rectangle.x + speed) + getWidth() <= conW) {
                position = RIGHT_FACING;
                rectangle.x += speed;
            }
            if (UP && (rectangle.y - speed) >= 0) {
                rectangle.y -= speed;
            }
            if (DOWN && (rectangle.y + speed) + getHeight() <= conH) {
                rectangle.y += speed;
            }
        }
    
        public int getPosition() {
            return position;
        }
    
        public Rectangle2D getBounds2D() {
            return rectangle.getBounds2D();
        }
    
        public boolean intersects(GameObject go) {
            return rectangle.intersects(go.getBounds2D());
        }
    }
    
    class Animator {
    
        private ArrayList<BufferedImage> frames;
        private ArrayList<Long> timings;
        private int currIndex;
        private long animationTime;
        private long totalAnimationDuration;
        private AtomicBoolean done;//used to keep track if a single set of frames/ an animtion has finished its loop
    
        public Animator(ArrayList<BufferedImage> frames, ArrayList< Long> timings) {
            currIndex = 0;
            animationTime = 0;
            totalAnimationDuration = 0;
            done = new AtomicBoolean(false);
            this.frames = new ArrayList<>();
            this.timings = new ArrayList<>();
            setFrames(frames, timings);
        }
    
        public boolean isDone() {
            return done.get();
        }
    
        public void reset() {
            totalAnimationDuration = 0;
            done.getAndSet(false);
        }
    
        public void update(long elapsedTime) {
            if (frames.size() > 1) {
                animationTime += elapsedTime;
                if (animationTime >= totalAnimationDuration) {
                    animationTime = animationTime % totalAnimationDuration;
                    currIndex = 0;
                    done.getAndSet(true);
                }
                while (animationTime > timings.get(currIndex)) {
                    currIndex++;
                }
            }
        }
    
        public BufferedImage getCurrentImage() {
            if (frames.isEmpty()) {
                return null;
            } else {
                try {
                    return frames.get(currIndex);
                } catch (Exception ex) {//images might have been altered so we reset the index and return first image of the new frames/animation 
                    currIndex = 0;
                    return frames.get(currIndex);
                }
            }
        }
    
        public void setFrames(ArrayList<BufferedImage> frames, ArrayList< Long> timings) {
            if (frames == null || timings == null) {//so that constructor super(null,null) cause this to throw NullPointerException
                return;
            }
            this.frames.clear();
            for (BufferedImage img : frames) {
                this.frames.add(img);
            }
            this.timings.clear();
            for (long animTime : timings) {
                totalAnimationDuration += animTime;
                this.timings.add(totalAnimationDuration);
            }
        }
    }
    
    abstract class GameLoop {
    
        private AtomicBoolean running, paused;
        private Thread gameLoopThread;
        //how many frames should be drawn in a second
        private final int FRAMES_PER_SECOND;
        //Calculate how many nano seconds each frame should take for our target frames per second.
        private final long TIME_BETWEEN_UPDATES;
        //track number of frames
        private int frameCount;
        //If you're worried about visual hitches more than perfect timing, set this to 1. else 5 should be okay
        private int MAX_UPDATES_BETWEEN_RENDER = 1;
    
        public GameLoop(int fps) {
            FRAMES_PER_SECOND = fps;
            TIME_BETWEEN_UPDATES = 1000000000 / FRAMES_PER_SECOND;
            gameLoopThread = null;
            frameCount = 0;
            running = new AtomicBoolean(false);
            paused = new AtomicBoolean(false);
        }
    
        void start() {
            if (gameLoopThread != null) {
                if (gameLoopThread.isAlive()) {
                    //System.out.println("Thwarted coders attempt to start a gameloop which has already been created");
                    return;
                }
            }
    
            gameLoopThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    gameLoop();
                }
            });
    
            gameLoopThread.start();
            running.set(true);
        }
    
        private void gameLoop() {
            //We will need the last update time.
            long lastUpdateTime = System.nanoTime();
            //store the time we started this will be used for updating map and charcter animations
            long currTime = System.currentTimeMillis();
    
            while (running.get()) {
                if (!paused.get()) {
                    long now = System.nanoTime();
                    long elapsedTime = System.currentTimeMillis() - currTime;
                    currTime += elapsedTime;
    
                    int updateCount = 0;
                    //Do as many game updates as we need to, potentially playing catchup.
                    while (now - lastUpdateTime >= TIME_BETWEEN_UPDATES && updateCount < MAX_UPDATES_BETWEEN_RENDER) {
                        update(elapsedTime);//Update the entity movements and collision checks etc (all has to do with updating the games status i.e  call move() on Enitites)
                        lastUpdateTime += TIME_BETWEEN_UPDATES;
                        updateCount++;
                    }
    
                    //If for some reason an update takes forever, we don't want to do an insane number of catchups.
                    //If you were doing some sort of game that needed to keep EXACT time, you would get rid of this.
                    if (now - lastUpdateTime >= TIME_BETWEEN_UPDATES) {
                        lastUpdateTime = now - TIME_BETWEEN_UPDATES;
                    }
    
                    draw();//draw the game by invokeing repaint (which will call paintComponent) on this JPanel
                    checkCollisions();//check for any collision
    
                    frameCount++;
                    long lastRenderTime = now;
    
                    //Yield until it has been at least the target time between renders. This saves the CPU from hogging.
                    while (now - lastRenderTime < TIME_BETWEEN_UPDATES && now - lastUpdateTime < TIME_BETWEEN_UPDATES) {
                        Thread.yield();
                        now = System.nanoTime();
                    }
                } else {//so we dont eat processor time when paused
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException ex) {
                        //do nothing
                    }
                }
            }
            //System.out.println("GameLoop done");
        }
    
        void pause() {
            paused.set(true);
        }
    
        void stop() {
            paused.set(false);
            running.set(false);
        }
    
        void resume() {
            paused.set(false);
        }
    
        boolean isPaused() {
            return paused.get();
        }
    
        boolean isRunning() {
            return running.get();
        }
    
        abstract void update(long elapsedTime);
    
        abstract void draw();
    
        abstract void checkCollisions();
    }