snerk

public class SnakeGame {
    private Snake player = new Snake();
    private JFrame window = new JFrame("Snake");
    private Timer timer = new Timer("Snake Ticker");
    private SnakeGameSettings settings = SnakeGameSettings.readOrNew();
    private int moveTimer = 0;
    private StoringKeyListener listener = new StoringKeyListener();
    private SnakeBoard board = new SnakeBoard(this.window.getGraphics().getClipBounds());

    private boolean paused = false;
    private boolean pauseScreenDisplayed = false;

    Logger logger = new Logger();

    public SnakeGame () {
        this.board.setPlayer(player);
        this.board.refresh();
    }

    public void start () {
        this.timer.schedule(this.new FrameTask(), 0L, 1000L / this.settings.framerate);
    }

    public void setPaused (boolean paused) {
        this.paused = paused;
    }

    void runFrame () {
        if (this.paused) this.runPausedFrame();
        if (this.pauseScreenDisplayed) this.accessPauseScreen(false, false);
        if (this.settings.getDifficulty().isSatisfied(this.moveTimer)) {
            if (!this.player.move()) this.gameOver();
            this.moveTimer = 0;
        } else {
            this.moveTimer++;
        }
        if (this.listener.up()) this.player.addBuffered(Snake.BUFFERED_INPUT_UP);
        if (this.listener.down()) this.player.addBuffered(Snake.BUFFERED_INPUT_DOWN);
        if (this.listener.left()) this.player.addBuffered(Snake.BUFFERED_INPUT_LEFT);
        if (this.listener.right()) this.player.addBuffered(Snake.BUFFERED_INPUT_RIGHT);
        if (this.listener.escape()) this.setPaused(true);
        this.keyListener.reset();
        if (this.window.isFocused()) this.renderFrame();
    }

    void renderFrame () {
        Graphics g = this.window.getGraphics();
        g.setColor(Color.BLACK);
        Rectangle clip = g.getClipBounds();
        g.fillRect(clip.getX(), clip.getY(), clip.getWidth(), clip.getHeight());
        g.setColor(Color.RED);
        for (Point p : this.board.getApples())
            g.fillRect((p.getX() * 8) + 1, (p.getY() * 8) + 1, 6, 6);
        List<Snake.Segment> snake = Arrays.asList(this.player.getSegments());
        g.setColor(Color.GREEN);
        for (Snake.Segment s : snake) {
            if (s.getFacingDirection() == Snake.Segment.DIRECTION_DOWN || s.getOriginDirection() == Snake.Segment.DIRECTION_DOWN)
                g.fillRect((s.getPos().getX() * 8) + 1, (s.getPos().getX() * 8) + 7, 6, 1);
            if (s.getFacingDirection() == Snake.Segment.DIRECTION_UP || s.getOriginDirection() == Snake.Segment.DIRECTION_UP)
                g.fillRect((s.getPos().getX() * 8) + 1, (s.getPos().getX() * 8) + 0, 6, 1);
            if (s.getFacingDirection() == Snake.Segment.DIRECTION_LEFT || s.getOriginDirection() == Snake.Segment.DIRECTION_LEFT)
                g.fillRect((s.getPos().getX() * 8) + 0, (s.getPos().getX() * 8) + 1, 1, 6);
            if (s.getFacingDirection() == Snake.Segment.DIRECTION_RIGHT || s.getOriginDirection() == Snake.Segment.DIRECTION_RIGHT)
                g.fillRect((s.getPos().getX() * 8) + 7, (s.getPos().getX() * 8) + 1, 1, 6);
            g.fillRect((s.getPos().getX() * 8) + 7, (s.getPos().getX() * 8) + 1, 1, 6);
        }
    }

    void closeGame () {
        this.window.dispose();
        this.timer.cancel();
        this.settings.save();
        this.board.dispose();
    }

    void runPausedFrame () {
        if (!this.paused) return;
        if (!this.pauseScreenDisplayed) this.accessPauseScreen(true, false);
        if (this.listener.escape()) this.setPaused(false);
    }

    void accessPauseScreen (boolean show, boolean settings) {
        if (show) {
            if (settings)
                this.window.add(this.newPauseScreen(), PAUSE_SCREEN_INDEX);
            else
                this.window.add(this.newSettingsScreen(), PAUSE_SCREEN_INDEX);
        } else {
            Component pauseScreen = this.window.get(PAUSE_SCREEN_INDEX);
            this.window.remove(pauseScreen);
            if (pauseScreen instanceof Container c) c.removeAll();
        }
        this.pauseScreenDisplayed = show;
    }

    JPanel newPauseScreen () {
        JPanel pauseScreen = new JPanel(new FlowLayout(FlowLayout.CENTER));
        JButton settingsB = new JButton("Settings");
        settingsB.setBackground(Color.GRAY);
        settingsB.setForeground(Color.BLACK);
        settingsB.addActionListener((e) -> { this.accessPauseScreen(true, true); });
        pauseScreen.add(settingsB);
        JButton exitB = new JButton("Exit game");
        exitB.setBackground(Color.RED);
        exitB.setForeground(Color.WHITE);
        exitB.addActionListener((e) -> { this.closeGame(); });
        pauseScreen.add(exitB);
        return pauseScreen;
    }

    JPanel newSettingsScreen () {
        JPanel pauseScreen = new JPanel(new FlowLayout(FlowLayout.CENTER));
        JLabel framerateL = new JLabel("Framerate");
        framerateL.setBackground(new Color(0, 0, 0, 0));
        framerateL.setForeground(Color.WHITE);
        pauseScreen.add(framerateL);
        JSlider framerateS = new JSlider(JSlider.HORIZONTAL, 60, 360, 60);
        framerateS.addChangeListener((e) -> { this.settings.setFramerate(((JSlider)e.getSource()).getValue()); });
        framerateS.setBackground(new Color(0, 0, 0, 0));
        pauseScreen.add(framerateS);
        JLabel difficultyL = new JLabel("Difficulty");
        difficultyL.setBackground(new Color(0, 0, 0, 0));
        difficultyL.setForeground(Color.WHITE);
        pauseScreen.add(difficultyL);
        JSlider difficultyS = new JSlider(JSlider.HORIZONTAL, 0, 1, 3);
        difficultyS.addChangeListener((e) -> { this.settings.setDifficulty(((JSlider)e.getSource()).getValue()); });
        difficultyS.setBackground(new Color(0, 0, 0, 0));
        pauseScreen.add(difficultyS);
        return pauseScreen;
    }

    class FrameTask extends TimerTask {
        private CompletableFuture<Void> lastFrame = CompletableFuture.runAsync(() -> { lastFrame.cancel(true); });

        public void run () {
            if (this.lastFrame.isCompletedExceptionally()) {
                try {
                    this.lastFrame.cancel(true);
                    this.lastFrame.get();
                } catch (ExecutionException ee) {
                    this.super.logger.error("Frame completion failed due to:\n");
                    ee.printStackTrace(this.super.logger);
                } catch (CancellationException ce) {
                    this.super.logger.warn("Frame completion was cancelled");
                } catch (InterruptedException ie) {
                    throw new IllegalStateException("Thread timed out while waiting for last frame to complete");
                }
                return;
            }
            if (!this.lastFrame.isDone()) {
                this.super.logger.warn("Lag frame occured");
                return;
            }
            this.lastFrame = CompletableFuture.runAsync(this.super::runFrame);
        }
    }
}

public class Logger extends PrintStream {
    private final boolean debug;
    private final PrintStream out;

    public Logger () {
        this (false, System.out);
    }

    public Logger (PrintStream out) {
        this (false, out);
    }

    public Logger (boolean debug) {
        this (debug, System.out);
    }

    public Logger (boolean debug, PrintStream out) {
        super (out);
        this.debug = debug;
        this.out = out;
    }

    public void log (String s) {
        this.out.println("[ LOGGER: Log at " + Instant.now().toString() + " ]: " + s);
    }

    public void warn (String s) {
        this.out.println("[ LOGGER: Warning at " + Instant.now().toString() + " ]: " + s);
    }

    public void error (String s) {
        this.out.println("[ LOGGER: Fatal error occured at " + Instant.now().toString() + " ]: " + s);
    }
}

public class StoringKeyListener implements KeyListener {
    private boolean up = false;

    public boolean up () {
        boolean b = this.up;
        this.up = false;
        return b;
    }

    private boolean down = false;

    public boolean down () {
        boolean b = this.down;
        this.down = false;
        return b;
    }

    private boolean left = false;

    public boolean left () {
        boolean b = this.left;
        this.left = false;
        return b;
    }

    private boolean right = false;

    public boolean right () {
        boolean b = this.right;
        this.right = false;
        return b;
    }

    private boolean escape = false;

    public boolean escape () {
        boolean b = this.escape;
        this.escape = false;
        return b;
    }

    public void keyPressed (KeyEvent evt) {
        if (evt.getKeyCode() == KeyEvent.VK_W || evt.getKeyCode() == KeyEvent.VK_KP_UP) this.up = true;
        if (evt.getKeyCode() == KeyEvent.VK_S || evt.getKeyCode() == KeyEvent.VK_KP_DOWN) this.down = true;
        if (evt.getKeyCode() == KeyEvent.VK_A || evt.getKeyCode() == KeyEvent.VK_KP_LEFT) this.left = true;
        if (evt.getKeyCode() == KeyEvent.VK_D || evt.getKeyCode() == KeyEvent.VK_KP_RIGHT) this.right = true;
        if (evt.getKeyCode() == KeyEvent.VK_ESCAPE) this.escape = true;
    }

    public void keyReleased (KeyEvent evt) {
        if (evt.getKeyCode() == KeyEvent.VK_W || evt.getKeyCode() == KeyEvent.VK_KP_UP) this.up = false;
        if (evt.getKeyCode() == KeyEvent.VK_S || evt.getKeyCode() == KeyEvent.VK_KP_DOWN) this.down = false;
        if (evt.getKeyCode() == KeyEvent.VK_A || evt.getKeyCode() == KeyEvent.VK_KP_LEFT) this.left = false;
        if (evt.getKeyCode() == KeyEvent.VK_D || evt.getKeyCode() == KeyEvent.VK_KP_RIGHT) this.right = false;
        if (evt.getKeyCode() == KeyEvent.VK_ESCAPE) this.escape = false;
    }

    public void keyTyped (KeyEvent evt) {}
}

public class SnakeBoard {
    private final Rectangle bounds;
    private Snake player = null;
    private Point[] apples;

    public SnakeBoard (Rectangle rect, int appleCount) {
        this.bounds = new Rectangle(rect.getX() / 8, rect.getY() / 8, rect.getWidth() / 8, rect.getHeight() / 8);
        this.apples = new Point[appleCount];
    }

    public void setPlayer (Snake snake) {
        this.player = snake;
    }

    public void refresh () {
        for (int i = 0; i <= this.apples.length; i++) {
            boolean invalidApple = true;
            while (invalidApple) {
                this.apples[i] = new Point(RandomGenerator.getDefault().nextInt(this.bounds.getWidth()) + this.bounds.getX(), RandomGenerator.getDefault().nextInt(this.bounds.getHeight()) + this.bounds.getY());
                for (Snake.Segment s : this.player.getSegments())
                    if (s.getPos() != this.apples[i]) invalidApple = false;
            }
        }
    }

    public Point[] getApples () {
        return this.apples;
    }

    public Rectangle getBounds () {
        return this.bounds;
    }
}