✦ JVDesignStudio · No Sign-Up Required

Java 2D Game Dev Cheat Sheet

A one-page printable reference for JFrame setup, game loop, Graphics2D, input, collision, sound and common Java game patterns. Pin it next to your monitor!

⚙️ JFrame Setup

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

JFrame frame = new JFrame("My Game");
GamePanel panel = new GamePanel();
panel.setPreferredSize(
    new Dimension(800, 600));

frame.add(panel);
frame.pack();
frame.setDefaultCloseOperation(
    JFrame.EXIT_ON_CLOSE);
frame.setResizable(false);
frame.setVisible(true);

🔄 Game Loop

public class GamePanel
    extends JPanel
    implements Runnable {

Thread gameThread;

public void startGameThread() {
    gameThread = new Thread(this);
    gameThread.start();
}

public void run() {
    while (true) {
        update();
        repaint();
        Toolkit.getDefaultToolkit()
               .sync();
    }
}

protected void paintComponent(
    Graphics g) {
    super.paintComponent(g);
    Graphics2D g2d =
        (Graphics2D) g;
    // draw here
}
}

✏️ Graphics2D

g2d.fillRect(x,y,w,h)	Drawing filled rectangle
g2d.fillOval(x,y,w,h)	Draw filled oval / circle
g2d.drawLine(x1,y1,x2,y2)	Draw a line
g2d.drawImage(img,x,y,w,h,null)	Draw scaled image
g2d.setColor(Color)	Set drawing colour
g2d.setFont(font)	Set font for text
g2d.drawString(str,x,y)	Draw text string
g2d.setRenderingHint()	Enable anti-aliasing

g2d.setRenderingHint(
    RenderingHints.KEY_ANTIALIASING,
    RenderingHints.VALUE_ANTIALIAS_ON);

🎨 Images

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;

BufferedImage img =
    ImageIO.read(
        new File("sprite.png"));

# scale to new size
Image scaled = img.getScaledInstance(
    64, 64, Image.SCALE_SMOOTH);

# convert to BufferedImage
BufferedImage bi =
    new BufferedImage(64, 64,
        BufferedImage.TYPE_INT_ARGB);
Graphics2D bgr = bi.createGraphics();
bgr.drawImage(scaled, 0, 0, null);
bgr.dispose();

🎮 Input (KeyListener)

import java.awt.event.*;

panel.addKeyListener(
    new KeyListener() {

  public void keyPressed(
      KeyEvent e) {
    int code = e.getKeyCode();
    if (code == KeyEvent.VK_LEFT)
        dx = -5;
    if (code == KeyEvent.VK_RIGHT)
        dx = 5;
  }

  public void keyReleased(
      KeyEvent e) {
    // reset movement
  }

  public void keyTyped(
      KeyEvent e) {}
});

panel.setFocusable(true);

💥 Collision

import java.awt.Rectangle;

Rectangle r1 =
    new Rectangle(x1, y1, w1, h1);
Rectangle r2 =
    new Rectangle(x2, y2, w2, h2);

# check intersection
if (r1.intersects(r2)) {
    System.out.println("Hit!");
}

# check if point inside
if (r1.contains(px, py)) {
    System.out.println("Inside!");
}

# access rect properties
r1.getX();   r1.getY();
r1.getWidth(); r1.getHeight();

🔢 Math

Math.abs(n)	Absolute value
Math.sqrt(n)	Square root
Math.atan2(dy, dx)	Angle from direction
Math.toDegrees(rad)	Convert radians → degrees
Math.toRadians(deg)	Convert degrees → radians
Math.random()	Random double [0.0, 1.0)
Math.min(a, b)	Minimum of two values
Math.max(a, b)	Maximum of two values

double dist = Math.sqrt(
    dx*dx + dy*dy);
double angle = Math.atan2(dy, dx);

🔊 Sound

import javax.sound.sampled.*;

AudioInputStream ais =
    AudioSystem.getAudioInputStream(
        new File("sfx.wav"));
Clip clip =
    AudioSystem.getClip();
clip.open(ais);
clip.start();

# loop forever
clip.loop(Clip.LOOP_CONTINUOUSLY);

# stop
clip.stop();

📐 Vector2 Helper

class Vector2 {
    double x, y;

    Vector2(double x, double y) {
        this.x = x;
        this.y = y;
    }

    Vector2 add(Vector2 v) {
        return new Vector2(x+v.x, y+v.y);
    }

    Vector2 multiply(double s) {
        return new Vector2(x*s, y*s);
    }

    double magnitude() {
        return Math.sqrt(x*x + y*y);
    }

    Vector2 normalize() {
        double m = magnitude();
        return new Vector2(x/m, y/m);
    }
}

🛠️ Common Patterns

── GAME LOOP WITH DELTA TIME ──
long lastTime = System.nanoTime();
double fps = 60.0;
double ns = 1000000000.0 / fps;

while (true) {
    long now = System.nanoTime();
    double delta = (now - lastTime) / ns;
    update(delta);
    repaint();
    lastTime = now;
}

── ENTITY SYSTEM ──
class Entity {
    double x, y, w, h, dx, dy;
    boolean alive = true;
    abstract void update(double dt);
    abstract void draw(Graphics2D g);
}

class EntityManager {
    List<Entity> entities = new ArrayList<>();
    void update(double dt) {
        entities.forEach(e -> e.update(dt));
        entities.removeIf(e -> !e.alive);
    }
    void draw(Graphics2D g) {
        entities.forEach(e -> e.draw(g));
    }
}

── SPRITE SHEET ANIMATION ──
int frame = 0, frameDelay = 10, tick = 0;
int frameW = img.getWidth() / cols;
int frameH = img.getHeight() / rows;

// in update():
tick++;
if (tick >= frameDelay) {
    tick = 0;
    frame = (frame + 1) % totalFrames;
}

// in draw():
int sx = (frame % cols) * frameW;
int sy = (frame / cols) * frameH;
g2d.drawImage(img, x, y, x+frameW,
    y+frameH, sx, sy, sx+frameW,
    sy+frameH, null);

── TILE MAP ──
int tileSize = 32;
for (int row = 0; row < map.length; row++) {
    for (int col = 0; col < map[0].length; col++) {
        int tile = map[row][col];
        g2d.drawImage(tileset[tile],
            col*tileSize, row*tileSize, null);
    }
}

── CAMERA FOLLOW ──
double camX = player.x - screenWidth/2;
double camY = player.y - screenHeight/2;
g2d.translate(-camX, -camY);
// draw world
g2d.translate(camX, camY);

Want to build a whole game?

Follow one of our free step-by-step workshops in the Workshop hub.

🔧 Browse Workshops →