Render class

package com.maestrum;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.awt.image.ConvolveOp;
import java.awt.image.Kernel;
import java.util.Random;

public class Render implements Runnable{

    public Graphics2D g2d;

    public double xScroll,yScroll;

    public int frames;
    public int fps;
    public long lastTime;

    public int[] pSequence = new int[40];
    public SpaceGame game;

    public Entity trackedEntity;

    public Random rand;

    public Render(SpaceGame game, Graphics2D g){
        this.game = game;
        this.g2d = g;
        this.rand = new Random();
        for(int i = 0 ; i < 40; i++){
            pSequence[i] = rand.nextInt(15) + 1;
        }
    }

    @Override
    public void run() {
        renderLoop();
    }

    public void renderLoop(){
        while(true){
            game.render();
            if(System.currentTimeMillis() - lastTime >= 1000){
                fps = frames;
                frames = 0;
                lastTime = System.currentTimeMillis();
            }
            frames++;
        }
    }

    public void renderPlanets(){
        overlayImage(ImageHandler.background, 0, 0, 1.5);
        for(int i = 0 ; i < 20; i++){
            overlayImage(ImageHandler.planets[pSequence[i]/4][pSequence[i]%4], i * 400 - xScroll/pSequence[i], i * pSequence[i]*40 - yScroll/pSequence[i]*2, pSequence[i]);
        }
    }

    private class PlanetRenderer {



    }

    public void overlayString(String s, double x, double y, int fontSize, int colour){
        drawString(s, x+xScroll, y+yScroll, fontSize, colour);
    }

    public void overlayRectangle(double x, double y, int xs, int ys, int colour){
        drawRectangle(x+xScroll, y+yScroll, xs, ys, colour);
    }

    public void overlayBlurred(BufferedImage img, double x, double y, double scale){
        drawImageBlurred(img, x+xScroll, y+yScroll, scale);
    }

    public void overlayImage(BufferedImage img, double x, double y, double scale){
        drawImage(img, x+xScroll, y+yScroll, scale);
    }

    public BufferedImage execute(BufferedImage img) {
        // TODO Auto-generated method stub
        float weight = 1.0f/2.0f;

        float [] elements = {weight, weight, weight, weight, weight, weight, weight, weight, weight};

        Kernel k = new Kernel (3,3,elements);
        ConvolveOp op = new ConvolveOp(k);

        BufferedImage dest = new BufferedImage(img.getWidth(), img.getHeight(), img.getType());

        op.filter(img, dest);
        return dest;
    }

    public void drawImageBlurred(BufferedImage img, double x, double y, double scale){
        x -= xScroll;
        y -= yScroll;
        BufferedImage image = new BufferedImage((int)(img.getWidth()*scale), (int)(img.getHeight()*scale), BufferedImage.TYPE_INT_ARGB);
        Graphics g = image.getGraphics();
        g.drawImage(img, 0, 0, (int)(img.getWidth()*scale), (int)(img.getHeight()*scale), null);
        execute(image);
        g2d.drawImage(image, (int)x, (int)y, null);
        g.dispose();
    }

    public void drawString(String s, Vector2D pos, int fontSize, int colour){
        drawString(s, pos.x, pos.y, fontSize, colour);
    }

    public void drawString(String s, double x, double y, int fontSize, int colour){
        if(s == null){
            return;
        }
        x -= xScroll;
        y -= yScroll;
        BufferedImage img = new BufferedImage(s.length()*fontSize+1, fontSize*2, BufferedImage.TYPE_INT_ARGB);
        Graphics g = img.getGraphics();
        g.setColor(new Color(colour));
        g.setFont(new Font("Consolas", Font.BOLD, fontSize));
        g.drawString(s, 0, img.getHeight()/2);
        g2d.drawImage(img, (int)x, (int)y, null);
        g.dispose();
    }

    public void drawImage(BufferedImage img, Vector2D pos, double scale){
        drawImage(img, pos.x, pos.y, scale);
    }

    public void drawLine(Vector2D v1, Vector2D v2, int colour, int width){
        drawLine(v1.x, v1.y, v2.x, v2.y, colour, width);
    }

    public void drawLine(double x1, double y1, double x2, double y2, int colour, int lWidth){
        x1 -= xScroll;
        y1 -= yScroll;
        x2 -= xScroll;
        y2 -= yScroll;
        g2d.setColor(new Color(colour));
        g2d.setStroke(new BasicStroke(lWidth));
        g2d.drawLine((int)x1, (int)y1, (int)x2, (int)y2);
    }

    public void drawImage(BufferedImage img, double x, double y, double scale){
        x -= xScroll;
        y -= yScroll;
        BufferedImage image = new BufferedImage((int)(img.getWidth()*scale), (int)(img.getHeight()*scale), BufferedImage.TYPE_INT_ARGB);
        Graphics g = image.getGraphics();
        g.drawImage(img, 0, 0, (int)(img.getWidth()*scale), (int)(img.getHeight()*scale), null);
        g2d.drawImage(image, (int)x, (int)y, null);
        g.dispose();
    }

    public void drawRectangle(Vector2D pos, int xs, int ys, int colour){
        drawRectangle(pos.x, pos.y, xs, ys, colour);
    }

    public void drawRectangle(double x, double y, int xs, int ys, int colour){
        if(xs <= 0){
            return;
        }
        x -= xScroll;
        y -= yScroll;
        BufferedImage image = new BufferedImage(xs, ys, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = (Graphics2D) image.getGraphics();
        g.setColor(new Color(colour));
        g.fillRect(0, 0, xs, ys);
        g2d.drawImage(image, (int)x, (int)y, null);
        g.dispose();
    }

    public void drawImageRotated(BufferedImage img, Vector2D pos, double scale, double angle) {
        drawImageRotated(img, pos.x, pos.y, scale, angle);
    }

     public void drawImageRotated(BufferedImage img, double x, double y, double scale, double angle) {
            x -= xScroll;
            y -= yScroll;
            BufferedImage image = new BufferedImage((int)(img.getWidth() * 1.5D), (int)(img.getHeight() * 1.5D), 2);
            Graphics2D g = (Graphics2D)image.getGraphics();
            g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g.rotate(Math.toRadians(angle), image.getWidth() / 2, image.getHeight() / 2);
            g.drawImage(img, image.getWidth() / 2 - img.getWidth() / 2, image.getHeight() / 2 - image.getHeight() / 2, null);
            g2d.drawImage(image, (int)(x-image.getWidth()*scale/2), (int)(y-image.getHeight()*scale/2), (int)(image.getWidth()*scale), (int)(image.getHeight()*scale), null);
            g.dispose();
     }

}