Java g.dispose not clearing screen

Question

I'm trying to make a 2D tile based game. I have been encountering an issue when attempting to draw new graphics and the old ones don't seem to have been removed.

If anyone knows why g.dispose isn't clearing the graphics then please help.

Here's my "Main" class:

package Main;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferStrategy;

import javax.swing.JFrame;

public class Main extends Canvas implements Runnable {

  private static final long serialVersionUID = 1L;

  private JFrame frame;

  static int size = 40;
  static int tilesX = 20;
  static int tilesY = 20;
  static int width = size * 10;
  static int height = size * 10;
  private boolean running = false;

  public static STATE state = STATE.MENU;
  public static PLAYER type = PLAYER.ARCHER;
  private Thread thread;

  static tileMap grid = new tileMap();
  tile[][] map = tileMap.map;

  public Main() {
    addKeyListener(new controls());
    addMouseListener(new mouse());
    Dimension wSize = new Dimension(width, height);
    setPreferredSize(wSize);
    frame = new JFrame();
  }

  public synchronized void start() {
    running = true;
    thread = new Thread(this, "game");
    thread.start();

  }

  public synchronized void stop() {
    running = false;
    try {
      thread.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }

  public enum STATE {
    MENU, GAME
  }

  public enum PLAYER {
    ARCHER, KNIGHT
  }

  public static void main(String[] args) {
    Main game = new Main();
    game.frame = new JFrame("Game");
    game.frame.add(game);
    game.frame.setResizable(false);
    game.frame.pack();
    game.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    game.frame.setVisible(true);
    game.start();
  }

  public void run() {
    while (running) {
      if (state == STATE.MENU) {
        menu();
      } else if (state == STATE.GAME) {
        tick();
        render();
      }
      try {
        Thread.sleep(16);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
  }

  private void menu() {
    BufferStrategy bs = getBufferStrategy();
    if (bs == null) {
      createBufferStrategy(2);
      return;
    }

    Graphics g = bs.getDrawGraphics();

    g.drawRect(Main.width / 8, 20, Main.width / 3, 200);
    g.drawString("Archer", Main.width / 8, 20);
    g.drawRect((Main.width - Main.width / 3) - Main.width / 8, 20,
      Main.width / 3, 200);
    g.drawString("Knight", (Main.width - Main.width / 3) - Main.width / 8,
      20);

    g.dispose();
    bs.show();
  }

  private void render() {
    BufferStrategy bs = getBufferStrategy();
    if (bs == null) {
      createBufferStrategy(3);
      return;
    }

    Graphics g = bs.getDrawGraphics();

    Graphics2D d = (Graphics2D) g;

    camera.setCam();

    g.translate(-camera.camX, -camera.camY);

    for (int i = 0; i < map.length; i++) {
      for (int j = 0; j < map[i].length; j++) {
        d.setColor(map[i][j].getC());
        d.fillRect(map[i][j].getX(), map[i][j].getY(), Main.size, Main.size);
        d.setColor(Color.BLACK);
        d.drawRect(map[i][j].getX(), map[i][j].getY(), Main.size, Main.size);
      }
    }

    map[player.p.getX()][player.p.getY()].setC(player.p.getC());



    if (type == PLAYER.ARCHER) {
      d.drawString("Archer", 5, 15);
    } else if (type == PLAYER.KNIGHT) {
      d.drawString("Knight", 5, 15);
    }

    g.dispose();
    bs.show();
  }

  static public void moved() {
    tileMap.map[player.p.getX()][player.p.getY()].setC(Color.GREEN);
  }

  private void tick() {
    if (player.p == null) {
      player.createP();
    }
  }
}

Answer 1

Graphics#dispose releases any internal resources that the Graphics context may be holding, reducing the memory overhead, it does not "clear" the context.

From the JavaDocs

Disposes of this graphics context and releases any system resources that it is using. A Graphics object cannot be used after dispose has been called.

What it doesn't do is effect the underlying content, that would be, well, annoying, as using a copy of a Graphics object is a good and easy way to make complex changes without effecting the original context.

To "clear" the context you could use fillRect to paint a color/background before you performing you next cycle of painting. Do this just after Graphics g = bs.getDrawGraphics();