path: root/src/subconscious/graphics/Scene.java

package subconscious.graphics;

import subconscious.Game;

import java.awt.Canvas;
import java.awt.Graphics2D;
import java.awt.Dimension;
import java.awt.BorderLayout;

import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.ComponentListener;
import java.awt.event.ComponentEvent;

import java.awt.image.BufferStrategy;

import javax.swing.JFrame;
import javax.swing.JPanel;


/* Scene
 * Abstract model class for all scenes of the game. Each scene is in a different
 * thread and renders with a double buffered. As threads, scenes can be paused
 * from rendering.
 *
 * It is also responsable for all inputs, which are transferred to the Game 
 * object which controls the internal state of the game.
 */
@SuppressWarnings("serial")
public abstract class Scene extends JPanel
	implements Runnable, KeyListener, MouseListener, MouseMotionListener, 
				MouseWheelListener, ComponentListener {

	// this is required to manage multiple scenes
	public final String UNIQUE_NAME;

	protected final long DESIRED_FPS = 60;
	protected final long DESIRED_DELTA_LOOP = (1000*1000*1000)/DESIRED_FPS;

	// Game is never be cached in the local thread
	protected volatile Game game;

	protected volatile boolean running;
	protected volatile boolean threadPaused;
	protected Object pauseLock;

	protected BufferStrategy buffer;
	protected Dimension canvasSize;
	protected Canvas canvas;

	// TODO: make accessible from user settings
	protected int guiSize = 2;

	public Scene(Game game, String uniqueName) {

		this.UNIQUE_NAME = uniqueName;
		this.game = game;

		// thread control
		this.running = false;
		this.threadPaused = false;
		this.pauseLock = new Object();

		// watch for resize
		this.addComponentListener(this);

		// set up canvas
		this.canvasSize = GameWindow.WINDOW_SIZE;
		this.canvas = new Canvas();	

		this.canvas.setBounds(0, 0, this.canvasSize.width, this.canvasSize.height);
		this.canvas.setIgnoreRepaint(true);

		this.canvas.addKeyListener(this);
		this.canvas.addMouseListener(this);
		this.canvas.addMouseMotionListener(this);
		this.canvas.addMouseWheelListener(this);

		// TODO: solve canvas
		// this.add(this.canvas, BorderLayout.CENTER);
		this.build();
	}

	/* abstract methods */
	// runs when the the scene thread starts
	protected abstract void build();
	// runs on each tick
	protected abstract void update(long deltaNanoTime);
	protected abstract void render(Graphics2D g);

	public void run() {
		long beginLoopTime;
		long endLoopTime;
		long currentUpdateTime = System.nanoTime();
		long lastUpdateTime;
		long deltaLoop;

		this.running = true;
		this.threadPaused = false;

		// wait for the canvas to be ready
		// this is required otherwise createBufferStrategy()
		// throws an IllegalStateException
		while (!this.canvas.isDisplayable() && running);

		// initialize canvas buffer
		this.canvas.createBufferStrategy(2);
		this.buffer = this.canvas.getBufferStrategy();
		this.canvas.requestFocus();	

		while (running) {
			beginLoopTime = System.nanoTime();

			do {
				do {
					Graphics2D g = (Graphics2D) this.buffer.getDrawGraphics();
					this.render(g);
					g.dispose();
				// repeat if the rendering buffer contents were restored
				} while (this.buffer.contentsRestored());
			// repeat if the drawing buffer contents were lost
			} while (this.buffer.contentsLost());

			try {
				this.buffer.show();
			} catch (IllegalStateException ex) {
				// this happens when the scene is hidden or the frame is disposed
				// for example then the thread is stopped, and so this exception
				// can be ignored
			}

			lastUpdateTime = currentUpdateTime;
			currentUpdateTime = System.nanoTime();

			// TODO: change to this.game.update(...)
			this.update(currentUpdateTime - lastUpdateTime);

			endLoopTime = System.nanoTime();
			deltaLoop = endLoopTime - beginLoopTime;

			if (deltaLoop > this.DESIRED_DELTA_LOOP) {
				// TODO: late => skip frame
			} else {
				try {
					Thread.sleep((this.DESIRED_DELTA_LOOP - deltaLoop)/(1000*1000));
				} catch (InterruptedException e ) {
					
				}
			}

			synchronized (this.pauseLock) {
				if (this.threadPaused) {
					try {
						this.pauseLock.wait();
					} catch (InterruptedException ex) {
						ex.printStackTrace();
					}
				}
			}
		}
	}

	/* game pause controls */
	public void stop() {
		// stop thread even if paused
		this.resumeThread();
		this.running = false;
	}

	public void pauseThread() {
		this.threadPaused = true;
	}

	public void resumeThread() {
		if (!this.threadPaused)
			return;

		this.threadPaused = false;

		synchronized (this.pauseLock) {
			this.pauseLock.notifyAll();
		}
	}


	// automagically set the canvas size to the parent's size
	// WARNING: does not always work
	// TODO: why doesn't this always work?
	public synchronized void updateCanvasSize() {
		this.canvasSize = this.getParent().getSize();
	}

	// this one always works
	public synchronized void updateCanvasSize(Dimension newSize) {
		this.canvasSize = newSize;
	}

	/* key listener */
	@Override public void keyTyped(KeyEvent e) {}
	@Override public void keyPressed(KeyEvent e) {}
	@Override public void keyReleased(KeyEvent e) {}
	
	/* mouse listener */
	@Override public void mouseClicked(MouseEvent e) {}
	@Override public void mouseEntered(MouseEvent e) {}
	@Override public void mouseExited(MouseEvent e) {}
	@Override public void mousePressed(MouseEvent e) {}
	@Override public void mouseReleased(MouseEvent e) {}
	@Override public void mouseDragged(MouseEvent e) {}
	@Override public void mouseMoved(MouseEvent e) {}
	@Override public void mouseWheelMoved(MouseWheelEvent e) {}

	/* component listener */
	@Override
	public void componentResized(ComponentEvent e) {
		this.updateCanvasSize();
	}

	@Override public void componentMoved(ComponentEvent e) {}
	@Override public void componentShown(ComponentEvent e) {}
	@Override public void componentHidden(ComponentEvent e) {}

}