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];
			}
		}
	}
}