Snake Game asking for feedback and improvements

[Ion Ciorici]

[img]I am not allowed to to use additional APIs (application programming interfaces), libraries other than what is available in the Java SDK API classes / interfaces.

Game class

import javax.swing.JFrame;

public class Game extends JFrame {

    private Game() {
        add(new Board());
        setResizable(false);
        pack();
        setTitle("fv18727");
        setLocationRelativeTo(null);
        setVisible(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

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

GameObjects Class

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

public abstract class GameObject {
    Integer posX, posY ; // X,Y coordinate

    public GameObject(Integer posX, Integer posY) {
        this.posX = posX;
        this.posY = posY;

        ArrayList<GameObject> gameobj = new ArrayList<>();
        gameobj.add(Board.snake);
        gameobj.add(Board.food);
    }
ArrayList<GameObject> gameobj = new ArrayList<>();
    abstract public void draw(Graphics g) ;
}

Board Class

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;
import javax.swing.border.LineBorder;

public class Board extends JPanel implements ActionListener {

    //The size of the window of the game
    public final static int WIDTH = 350;
    public final static int HEIGHT = 350;

    //Means pixel size of food & our snake
    protected final static int DOTS = 35;
    protected static int headdirection = 0 ;
    public static boolean direction = true;

// The total amount of pixels the game could possibly have
    private final static int TOTALDOTS = (WIDTH * HEIGHT)
            / (DOTS * DOTS);

    // Check to see if the game is running
    public static boolean inGame = true;

    // Timer used to record tick times
    protected static Timer timer;

    // Game speed is for setting the speed of our snake in the game
    //lower means faster
    private static int speed = 150;

    // Instances of our food & snake to use their methods
    protected static Snake snake = new Snake(0,0);
    protected static Food food = new Food(0,0);


    // To keep track  of our in Game score;
    public static int score = 0;

    //Instance of the score class to access its methods
    public static Score scoreReport = new Score();

    JButton restartButton = new JButton("New Game");
    JButton QuitGame = new JButton("Quit");
    JTextArea text = new JTextArea(20,20);


    public Board() {

        setFocusable(true);
        setPreferredSize(new Dimension(WIDTH,HEIGHT));
        initialize();

        Font font = new Font("Helvetica", Font.BOLD, 20);
        restartButton.setFont(font);
        QuitGame.setFont(font);

        setLayout(null);
        restartButton.setBounds(48,220,130,35);
        QuitGame.setBounds(190,220,130,35);
        text.setBounds(50,105,270,115);
        text.setBackground(Color.DARK_GRAY);


        add(restartButton);
        add(QuitGame);
        add(text);

        addKeyListener(new KeyArrows(this));
        restartButton.addActionListener(new restartBt_ActionList(this));
        QuitGame.addActionListener(new QuitG_Listener());

        restartButton.setVisible(false);
        QuitGame.setVisible(false);
        text.setEditable(false);
        text.setVisible(false);
    }

    private boolean nearness(int a, int b, int inrange) {
        return Math.abs((long) a - b) <= inrange;
    }

    public static int getDots() {
        return TOTALDOTS;
    }

    public static int getDotSize() {
        return DOTS;
    }

    // Used to paint our components
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        draw(g);
    }
    // Draw our Black and white board
    void draw(Graphics g) {
        for (int row = 0; row < 10; row++) {
            for (int col = 0; col < 10; col++) {
                int i = col * 35;
                int j = row * 35;
                if ((row % 2) == (col % 2))
                    g.setColor(Color.black);
                else
                    g.setColor(Color.white);
                    g.fillRect(i, j, 50, 50);
            }
        }
        if (inGame) {
            food.draw(g);
            snake.draw(g);
        }else{
                // If Snake is not alive then ,it is GameOver
                GameOver(g);
            }
       }

   private void startMessage(Graphics g) {
        String message = "Press an arrow key to start the game";
        g.setColor(Color.RED);
        g.setFont(new Font("Helvetica", Font.BOLD, 18));
        g.drawString(message, 10, 100);

    }

    void initialize() {
        snake.setBodyparts(3); // set initial snake size

        // Create the body of the snake
        snake.createBody();
        // Generate first food
        food.createFood();

        // Make the game move setting the timer to know the speed of the game
        timer = new Timer(speed, this);
        timer.start();
    }

    // Check if snake intersects food
    void FoodCollision() {

        if ((nearness(snake.getX(0), food.getX(), 20))
                && (nearness(snake.getY(0), food.getY(), 20))) {

            System.out.println("intersection");
            // increase the snake size
            snake.setBodyparts(snake.getBodyparts() + 1);
            score += 1;

            // Create next food
            food.createFood();
        }
    }
    private void GameOver(Graphics g) {
        g.setColor(Color.RED);
        g.setFont(new Font("Helvetica", Font.BOLD, 30));
        g.drawString("GAME OVER", 90, 100);
        restartButton.setVisible(true);
        QuitGame.setVisible(true);
        text.setVisible(true);

        //System.out.println(score);
        TreeSet scorr = null;
        try {
            scorr = scoreReport.SetofScores(scoreReport.readFromFile("scores.txt"));

        } catch (IOException e) {
            e.printStackTrace();
        }

        Object[] arr = scorr.toArray();
        int[] revarr = new int[5];
        int j = 0;
        int len = arr.length;
        for (int i = 0; i <5 && (len>= len-5 && len>0) ; i++) {
            revarr[i] = (int) arr[len-1];
            j = j + 1;
            len = len -1;
        }
          //System.out.println(Arrays.toString(revarr));
        String formatString = Arrays.toString(revarr)
                .replace(",", "  points\n                        ")  //remove the commas
                .replace("[", " ")  //remove the right bracket
                .replace("]", "  points"); //remove the left bracket

        //System.out.println(formatString+"\n");

        g.setColor(Color.WHITE);
        String thisround = "                 This round score: " + score;
        text.setFont(Font.getFont("Helvetica"));
        text.setText(thisround + "\n                      TOP 5 SCORES:\n" + "                        "+formatString);
        text.setForeground(Color.white);
        text.setBorder(new LineBorder(Color.BLACK));

    }

    // Snake moves,and permanent checks as long as we are in the game
    @Override
    public void actionPerformed(ActionEvent e) {
        if (inGame) {

            FoodCollision();
            snake.Collisions();
            snake.move();

            System.out.println(snake.getX(0) + " " + snake.getY(0)
                    + " " + food.getX() + ", " + food.getY());
        }
        // Repaint our screen
        repaint();
    }
}

Food Class

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

public class Food extends GameObject {

    private Snake snake = new Snake(0, 0);
    private int foodX; // X coordinate of food
    private int foodY; //Y coordinate of food

    // Used to determine random position of food
    private final int RANDOMPOSITION = 10;

    public Food(Integer foodX, Integer foodY) {
        super(foodX, foodY);
    }

    public void createFood() {

        // Set our food's x & y position to a random position
        int location = (int) (Math.random() * RANDOMPOSITION);

        foodX = ((location * Board.getDotSize()));

        location = (int) (Math.random() * RANDOMPOSITION);

        foodY = ((location * Board.getDotSize()));

        if ((foodX == snake.getX(0)) && (foodY == snake.getY(0))) {
            createFood();
        }
    }

    public int getX() {
        return foodX;
    }

    public int getY() {
        return foodY;
    }

    public void draw(Graphics g) {

        ImageIcon apple = new ImageIcon("/Users/filipvacarciuc/IdeaProjects/SnakeG/src/res/apple.png");
        apple.paintIcon(null, g, getX(), getY()); // Drawing the food using a image
    }
}

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class KeyArrows implements KeyListener {
    private Board theApp;
    public KeyArrows(Board app){
        this.theApp=app;
    }

    @Override
    public void keyTyped(KeyEvent keyEvent) {
    }

    @Override
    public void keyPressed(KeyEvent keyEvent) {
        int code = keyEvent.getKeyCode();


        if ((code == KeyEvent.VK_LEFT) && (! theApp.snake.isRightDirection())) {
            Board.direction= false;
            theApp.snake.setLeftDirection(true);
            Board.headdirection = 1 ;
            theApp.snake.setUpDirection(false);
            theApp.snake.setDownDirection(false);
        }

        if ((code == KeyEvent.VK_RIGHT) && (! theApp.snake.isLeftDirection())) {
            Board.direction= false;
            theApp.snake.setRightDirection(true);
            Board.headdirection = 0 ;
            theApp.snake.setUpDirection(false);
            theApp.snake.setDownDirection(false);
        }

        if ((code == KeyEvent.VK_UP) && (! theApp.snake.isDownDirection())) {
            Board.direction= false;
            theApp.snake.setUpDirection(true);
            Board.headdirection = 2 ;
            theApp.snake.setRightDirection(false);
            theApp.snake.setLeftDirection(false);
        }

        if ((code == KeyEvent.VK_DOWN) && (! theApp.snake.isUpDirection())) {
            Board.direction = false;
            theApp.snake.setDownDirection(true);
            Board.headdirection = 3;
            theApp.snake.setRightDirection(false);
            theApp.snake.setLeftDirection(false);
        }

    }

    @Override
    public void keyReleased(KeyEvent keyEvent) {
    }
}

Class QuitG_Listener

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class QuitG_Listener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        System.exit(0);
    }
}

RestartBt_ActionListener

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class restartBt_ActionList implements ActionListener {
    private Board theApp;
    public restartBt_ActionList(Board app){
        theApp=app;
    }
    @Override
    public void actionPerformed(ActionEvent actionEvent) {
        theApp.text.setVisible(false);
        theApp.inGame = true;
        theApp.direction = true;
        theApp.headdirection= 0;
        theApp.score = 0;
        theApp.snake.setDownDirection(false);
        theApp.snake.setRightDirection(false);
        theApp.snake.setLeftDirection(false);
        theApp.snake.setUpDirection(false);
        theApp.initialize();
        theApp.restartButton.setVisible(false);
        theApp.QuitGame.setVisible(false);
    }
}

Score class

import java.io.*;
import java.util.*;

public class Score {

    public void saveScore(int score) {
        File file = new File("scores.txt");
        try {
            BufferedWriter output = new BufferedWriter(new FileWriter(file, true));
            output.newLine();
            output.append("" + score);
            output.close();

        } catch (IOException ez1) {
            System.out.printf("ERROR writing score to file: %s\n", ez1);
        }
    }

    public TreeSet<Integer>SetofScores(List<Integer> scores) {
        TreeSet<Integer> set = new TreeSet<>();

        int i = 0;
        while (i < scores.size()) {
            set.add(scores.get(i));
            i++;
        }
        return set;
    }

    public static List<Integer> readFromFile(String pFilename) throws IOException {
        try {
            BufferedReader in = new BufferedReader(new FileReader(pFilename));
            List<Integer> scores = new ArrayList<>();
            String c;
            while ((c = in.readLine()) != null) {
                //data.append((char)c);
                if (c.length() != 0)
                    scores.add(Integer.parseInt(c));
            }
            in.close();
            //System.out.printf(String.valueOf(scores));
            return scores;
        }catch (FileNotFoundException ex) {
            ex.printStackTrace();
        }
        return new ArrayList<>();
    }
}

Snake Class

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

public class Snake extends GameObject {

    // Stores the joints / body part locations for our snake
    private final int[] x = new int[Board.getDots()];
    private final int[] y = new int[Board.getDots()];


    // Stores direction of our snake
    private boolean leftDirection = false;
    private boolean rightDirection = false;
    private boolean upDirection = false;
    private boolean DownDirection = false;

    private int bodyparts = 0; //body parts of the snake
    public Snake(Integer posX, Integer posY) {
        super(posX, posY);
    }


    public int getX(int index) {
        return x[index];
    }

    public int getY(int index) {
        return y[index];
    }

    public void setX(int i) {
        x[0] = i;
    }

    public void setY(int i) {
        y[0] = i;
    }

    public boolean isLeftDirection() {
        return leftDirection;
    }

    public void setLeftDirection(boolean leftDirection) {
        this.leftDirection = leftDirection;
    }

    public boolean isRightDirection() {
        return rightDirection;
    }

    public void setRightDirection(boolean rightDirection) {
        this.rightDirection = rightDirection;
    }

    public boolean isUpDirection() {
        return upDirection;
    }

    public void setUpDirection(boolean upDirection) {
        this.upDirection = upDirection;
    }

    public boolean isDownDirection() {
        return DownDirection;
    }

    public void setDownDirection(boolean downDirection) {
        this.DownDirection = downDirection;
    }

    public int getBodyparts() {
        return bodyparts;
    }


    public void setBodyparts(int l) {
        bodyparts = l;
    }

    public void move() {
        for (int i = bodyparts; i > 0; i--) {

            // Moves the joints of the snake 'up the chain'
            // Meaning, the joint of the snake all move up one
            x[i] = x[(i - 1)];
            y[i] = y[(i - 1)];
        }

        // Moves snake to the left
        if (leftDirection) {
            x[0] -= Board.getDotSize();
        }
        // To the right
        if (rightDirection) {
            x[0] += Board.getDotSize();
        }
        // Down
        if (DownDirection) {
            y[0] += Board.getDotSize();
        }
        // And finally up
        if (upDirection) {
            y[0] -= Board.getDotSize();
        }

        // Dotsize represents the size of the joint, so a pixel of DOTSIZE
        // gets added on to the snake in that direction
    }

    //draw only if the game is running
    public void draw(Graphics g) {
            // Draw our snake.
            for (int i = 0; i < getBodyparts(); i++) {
                // Snake's head for different facing directions
                if (i == 0 && Board.headdirection==0) {
                    ImageIcon im = new ImageIcon("/Users/filipvacarciuc/IdeaProjects/SnakeG/src/res/head.png");
                    im.paintIcon(null, g, getX(i), getY(i));
                }
                else if(i == 0 && Board.headdirection==1)   {
                    ImageIcon im = new ImageIcon("/Users/filipvacarciuc/IdeaProjects/SnakeG/src/res/head_left.png");
                    im.paintIcon(null, g, getX(i), getY(i));
                }
                else if(i == 0 && Board.headdirection==2)   {
                    ImageIcon im = new ImageIcon("/Users/filipvacarciuc/IdeaProjects/SnakeG/src/res/head_up.png");
                    im.paintIcon(null, g, getX(i), getY(i));
                }
                else if(i == 0 && Board.headdirection==3)   {
                    ImageIcon im = new ImageIcon("/Users/filipvacarciuc/IdeaProjects/SnakeG/src/res/head_down.png");
                    im.paintIcon(null, g, getX(i), getY(i));
                }
                // draw snake's body when it is not moving
                else if(i==1 && Board.direction){
                    g.setColor(Color.red);
                    Graphics2D g2 = (Graphics2D) g;
                    g2.fill(new Ellipse2D.Double(getX(i)-35, getY(i), Board.DOTS, Board.DOTS));
                }
                else if(i==2 && Board.direction){
                    g.setColor(Color.red);
                    Graphics2D g2 = (Graphics2D) g;
                    g2.fill(new Ellipse2D.Double(getX(i)-70, getY(i), Board.DOTS, Board.DOTS));
                }
                // snake's Body when it is moving
                else {
                    g.setColor(Color.red);
                    Graphics2D g2 = (Graphics2D) g;
                    g2.fill(new Ellipse2D.Double(getX(i), getY(i), Board.DOTS, Board.DOTS));
                }
            }
            // Syncronising all graphics
            Toolkit.getDefaultToolkit().sync();
        }

    //check intersection with snake body and borders
    protected void Collisions() {

        // If the snake touches its body
        for (int i = getBodyparts(); i > 0; i--) {

            // Snake cannot touch itself if it's less than 5
            if ((i > 5)
                    && (getX(0) == getX(i) && (getY(0) == getY(i)))) {
                Board.scoreReport.saveScore(Board.score);
                Board.inGame = false; //Game ends
            }
        }

        // If snake goes past the borders of the game
        if (getY(0) >= Board.HEIGHT) {
            Board.scoreReport.saveScore(Board.score);
            Board.inGame = false;
        }

        if (getY(0) < 0) {
            Board.scoreReport.saveScore(Board.score);
            Board.inGame = false;
        }

        if (getX(0) >= Board.WIDTH) {
            Board.scoreReport.saveScore(Board.score);
            Board.inGame = false;
        }

        if (getX(0) < 0) {
            Board.scoreReport.saveScore(Board.score);
            Board.inGame = false;
        }

        // If game ended,we stop our timer
        if (!Board.inGame) {
            Board.timer.stop();

        }
    }

    protected void createBody() {
        for (int i = 0; i < getBodyparts(); i++) {
            setX(Board.WIDTH / 2);
            setY(Board.HEIGHT / 2);
        }

    }
}

[/img]

[Campbell Ritchie]

As a general rule, I don't like extending display classes. It is however a good idea to extend JPanel to override its paintComponent(Graphics) method.
I also think it is usually a bad idea to make a display class implement ActionListener.

[Ion Ciorici]

What about storing objects in a collection? What are the usages and did I make it properly?
Also, for the images that I want to use in the game is there a better way to use  images because it is only bounded to the file path of my computer at the  moment

[S Fox]

you need to make a package and store the images as resources in the package, then you can load them from there, and it means you can distribute the program.

[Piet Souris]

What use does the GameObject have?  It exists of two GameObjects, Snake and Food, but what use is the posX and posY fields? For Snake these are unnecessary, and a Food has its own x and y.

Then it could be a Collection of GameObjects, but the Board draws a Snake and a Food literally, so it doesn't use a GameObject as Collection.

Why does the Food class have a field: Snake snake? I did not see any code using this field.

So, at a glance I'd say get rid of the GameObject class, make an interface Drawable, that has a method 'draw' and let Snake and Food implement this interface.

Lastly (for now) don't let the 'draw' method load an image. Load these images at startup.

But I like the idea and it certainly would work. As soon as I have created some images, I'll have a go playing the game. The last time I played Snakes, was it in the 80's or 90's?

[Ion Ciorici]

Can you advise me how can I make use of the GameObject
I need to have an abstract class that is used for Snake and Food to inherit its methods related to how the game
objects are displayed and manipulated and suitably overridden

[Junilu Lacar]

What's the point of lines 11-13 in this constructor?
   public GameObject(Integer posX, Integer posY) {        this.posX = posX;        this.posY = posY;        ArrayList<GameObject> gameobj = new ArrayList<>();        gameobj.add(Board.snake);        gameobj.add(Board.food);    }
gameobj is declared and assigned a new ArrayList<GameObject> instance. However, this is a local variable and it is not assigned to any instance variable so when the constructor exits, it will simply vanish without a trace. It's quite pointless from what I can tell.

[Junilu Lacar]

Referring to Line 6 of the Food class, why would a Food object have a Snake object as one of its attributes/fields? Can you explain your reasons for doing that?