package game;

import graphics.Screen;
import graphics.SpriteSheet;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;

import javax.swing.JFrame;

public class Game extends Canvas implements Runnable{


    private static final long serialVersionUID = 1L;

    public static final int WIDTH = 160;
    public static final int HEIGHT = WIDTH/12*9;
    public static final int SCALE = 3;
    public static final String NAME = "Forgotten Realm";

    private JFrame frame;

    public boolean running = false;
    public int updateCount = 0;

    private BufferedImage image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
    private int[] pixels =((DataBufferInt)image.getRaster().getDataBuffer()).getData();

    private Screen screen;

    public Game(){
        setMinimumSize(new Dimension(WIDTH*SCALE,HEIGHT*SCALE));
        setMaximumSize(new Dimension(WIDTH*SCALE,HEIGHT*SCALE));
        setPreferredSize(new Dimension(WIDTH*SCALE,HEIGHT*SCALE));

        frame = new JFrame(NAME);

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new BorderLayout());

        frame.add(this, BorderLayout.CENTER);
        frame.pack();

        frame.setResizable(false);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }

    public void init()
    {
        screen = new Screen(WIDTH, HEIGHT, new SpriteSheet("/sprite_sheet.png"));
    }

    public synchronized void start(){
        running = true;
        new Thread(this).start();
    }
    public synchronized void stop(){
        running = false;
    }
    public void run() {
        long lastTime = System.nanoTime();
        double nanosecondsPerUpdate = 1000000000D/60D;

        int updates = 0;
        int frames = 0;

        long lastTimer = System.currentTimeMillis();

        double delta = 0;

        init();

        while(running)
        {
            long now = System.nanoTime();
            delta += (now - lastTime)/nanosecondsPerUpdate;
            lastTime = now;
            boolean shouldRender = true;

            while(delta >= 1)
            {
            updates++;
            update();
            delta -= 1;
            shouldRender = true;
            }

            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if(shouldRender)
            {
            frames++;
            draw();
            }

            if(System.currentTimeMillis() - lastTimer >= 1000)
            {
                lastTimer += 1000;
                System.out.println(updates + " updates, "+frames + " frames");
                frames = 0;
                updates = 0;
            }
        }
    }

    public void update(){
        updateCount++;
        for(int i = 0; i < pixels.length;i++)
        {
            pixels[i] = i + updateCount;
        }
    }
    public void draw(){
        BufferStrategy bs = getBufferStrategy();
        if(bs == null)
        {
            createBufferStrategy(3);
            return;
        }

        screen.draw(pixels, 0, WIDTH);

        Graphics g = bs.getDrawGraphics();

        g.drawRect(0,0, getWidth(), getHeight());
        g.drawImage(image, 0, 0, getWidth(), getHeight(), null);

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

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

}


package graphics;

import java.awt.image.BufferedImage;
import java.io.IOException;

import javax.imageio.ImageIO;

public class SpriteSheet {
    public String path;
    public int width;
    public int height;

    public int[] pixels;

    public SpriteSheet(String path)
    {
        BufferedImage image = null;

        try {
            image = ImageIO.read(SpriteSheet.class.getResourceAsStream(path));
        } catch (IOException e) {
            e.printStackTrace();
        }

        if(image == null)
        {
            return;
        }

        this.path = path;
        this.width = image.getWidth();
        this.height = image.getHeight();

        pixels = image.getRGB(0, 0, width, height, null, 0, width);

        for(int i = 0; i < pixels.length; i++)
        {
            //Removes alpha channels
            //AARRGGBB
            //256/4 = ~64
            pixels[i] = (pixels[i]&0xff) / 64;
        }
    }
}


package graphics;

public class Screen {

    public static final int MAP_WIDTH = 64;
    public static final int MAP_WIDTH_MASK = MAP_WIDTH -1;

    public int[] tiles = new int[MAP_WIDTH * MAP_WIDTH];
    public int[] colors = new int[MAP_WIDTH * MAP_WIDTH * 4];

    public int xOffset = 0;
    public int yOffset = 0;

    public int width;
    public int height;

    public SpriteSheet sheet;

    public Screen(int width, int height, SpriteSheet sheet)
    {
        this.width = width;
        this.height = height;
        this.sheet = sheet;

        for(int i = 0; i < MAP_WIDTH * MAP_WIDTH; i++)
        {
            //What they correspond to on the sprite_sheet
            colors[i*4+0] = 0xff00ff; //Black
            colors[i*4+1] = 0x00ffff; //Dark Color
            colors[i*4+2] = 0xffff00; //Other Dark Color
            colors[i*4+3] = 0xffffff; //White
        }
    }

    public void draw(int[] pixels, int offset, int row)
    {
        //Variables
        int xTile = 0;
        int yTile = 0;
        int xMin = 0;
        int xMax = 0;
        int yMin = 0;
        int yMax = 0;

        for(yTile = yOffset >> 3;yTile <= (yOffset + height) >>3;yTile++)
        {
            yMin = yTile * 8 - yOffset;
            yMax = yMin + 8;
            if(yMin < 0) yMin = 0;
            if(yMax > height) yMax = height;
        }
        for(xTile = xOffset >> 3;xTile <= (xOffset + width) >>3;xTile++)
        {
            xMin = xTile * 8 - xOffset;
            xMax = xMin + 8;
            if(xMin < 0) xMin = 0;
            if(xMax > width) xMax = width;
        }
        int tileIndex = (xTile & (MAP_WIDTH_MASK)) + (yTile &(MAP_WIDTH_MASK)) * MAP_WIDTH;

        for(int y = 0; y <yMax;y++)
        {
            //Goes through it and draws it.
            int sheetPixel =(y+yOffset & 7) * sheet.width + ((xMin + xOffset) & 7);
            int tilePixel = offset + xMin + y * row;

            for(int x = xMin; x < xMax; x++)
            {
                int color = tileIndex * 4 + sheet.pixels[sheetPixel++];
                pixels[tilePixel++] = colors[color];
            }
        }
    }
}