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

package subconscious.graphics;

import subconscious.Game;

import subconscious.graphics.widget.Widget;
import subconscious.graphics.widget.Clickable;
import subconscious.graphics.widget.Dynamic;

import subconscious.graphics.widget.PerfView;

import java.lang.Thread;

import java.util.ArrayList;
import java.util.Map;
import java.util.EnumMap;

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.Condition;

import java.io.InputStream;
import java.io.IOException;

import java.awt.Canvas;
import java.awt.Graphics2D;
import java.awt.Dimension;
import java.awt.BorderLayout;
import java.awt.Panel;
import java.awt.RenderingHints;
import java.awt.Font;
import java.awt.FontFormatException;
import java.awt.Point;

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;



/* 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 Panel
	implements Runnable, KeyListener, MouseListener, MouseMotionListener, 
				MouseWheelListener, ComponentListener {

	// this is required to manage multiple scenes
	public final String UNIQUE_NAME;
	private static int absScenesCount = 0;

	public static final long DESIRED_FPS = 80;
	public static final long DESIRED_DELTA_LOOP_NS = (1000*1000*1000)/DESIRED_FPS;
	public static final long NO_DELAYS_PER_YELD = 15;
	public static final Map<RenderingHints.Key, ?> RENDERING_HINTS = Map.of(
		RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON,
		RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON,
		RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED,
		RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR,
		// RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR,
		RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED
	);

	protected final EnumMap<Widget.Anchor, Point> widgetAnchors = new EnumMap<Widget.Anchor, Point>(Widget.Anchor.class);
	private ArrayList<Widget> widgets = new ArrayList<>();
	private ArrayList<Widget> dynamicWidgetsCache = new ArrayList<>();
	private ArrayList<Widget> clickableWidgetsCache = new ArrayList<>();

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

	// TODO: this could become a Queue of scenes to load
	protected Scene requestedScene = null;
	protected boolean requestedPrevScene = false;

	protected volatile boolean running = true;
	protected volatile boolean threadPaused = false;
	protected Lock pauseLock = new ReentrantLock();
	protected Condition threadResumed = pauseLock.newCondition();

	protected volatile Dimension canvasSize = GameWindow.WINDOW_SIZE;
	protected Canvas canvas = new Canvas();
	protected BufferStrategy buffer;

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

	public Scene(Game game, String label) {
		// generate unique name
		String uniqueName = this.getClass().getCanonicalName() + Integer.toString(Scene.absScenesCount);
		Scene.absScenesCount++;

		this.UNIQUE_NAME = uniqueName + " (" + label + ")";
		this.game = game;

		// set default scene font unscii

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

		// set up 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

		// create widget anchors 
		this.widgetAnchors.put(Widget.Anchor.SO, new Point(0, this.canvasSize.height));
		this.widgetAnchors.put(Widget.Anchor.S , new Point(this.canvasSize.width / 2, this.canvasSize.height));
		this.widgetAnchors.put(Widget.Anchor.SE, new Point(this.canvasSize.width, this.canvasSize.height));
		this.widgetAnchors.put(Widget.Anchor.E , new Point(this.canvasSize.width, this.canvasSize.width / 2));
		this.widgetAnchors.put(Widget.Anchor.NE, new Point(this.canvasSize.width, 0));
		this.widgetAnchors.put(Widget.Anchor.N , new Point(this.canvasSize.width / 2, 0));
		this.widgetAnchors.put(Widget.Anchor.NO, new Point(0, 0));
		this.widgetAnchors.put(Widget.Anchor.O , new Point(0, this.canvasSize.height / 2));

		// this.add(this.canvas, BorderLayout.CENTER);
		this.build();

		// TODO: this will be controlled in the settings
		this.addWidget(new PerfView("default-perfview", 0, 0));
	}

	public Scene(Game game) {
		this(game, "");
	}

	/* */

	/* 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);

	protected void updateWidgets(long deltaNanoTime) {
		for (Widget w : this.dynamicWidgetsCache) {
			((Dynamic) w).update(deltaNanoTime);
		}
	}

	protected void renderWidgets(Graphics2D g) {
		for (Widget w : this.widgets) {
			Point absPos = new Point(this.widgetAnchors.get(w.getAnchor()));
			absPos.translate(w.getX(), w.getY());

			Graphics2D widgetGraphics = (Graphics2D) g.create(
				absPos.x, absPos.y, w.getWidth(), w.getHeight()
			);

			w.render(widgetGraphics);
			widgetGraphics.dispose();
		}
	}

	/* widgets management */
	protected void addWidget(Widget widget) {
		this.widgets.add(widget);

		if (widget instanceof Dynamic) {
			this.dynamicWidgetsCache.add(widget);
		}

		if (widget instanceof Clickable) {
			this.clickableWidgetsCache.add(widget);
		}
	}

	protected void removeWidget(Widget widget) {
		// TODO
		throw new UnsupportedOperationException("TODO");
	}

	/* request scenes */
	protected synchronized void requestPrevScene() {
		this.requestedPrevScene = true;
	}

	protected synchronized boolean isRequestingPrevScene() {
		return this.requestedPrevScene;
	}

	protected synchronized void requestScene(Scene sc) {
		if (this.requestedScene != null)
			throw new UnsupportedOperationException("only one scene can be requested at once");

		this.requestedScene = sc;
	}

	// TODO: protected synchronized void requestScene(String uniqueName) {}

	public synchronized boolean isRequestingScene() {
		return this.requestedScene != null;
	}

	public synchronized Scene getRequestedScene() {
		Scene requested = this.requestedScene;
		this.requestedScene = null;

		return requested;
	}

	/* runnable implementation */
	public void run() {
		long beforeTime, afterTime, timeDiff = 0, sleepTime;
		long overSleepTime = 0L;
		int noDelays = 0;

		this.running = true;

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

		// initialize canvas buffer
		// the condition checks because the while above can be interrupted by
		// changing this.running
		// TODO: this is because of the MainMenuScene which hides the canvas
		//       when the scene will be fixed this if can be removed
		if (this.canvas.isDisplayable()) {
			this.canvas.createBufferStrategy(2);
			this.buffer = this.canvas.getBufferStrategy();
			this.canvas.requestFocus();	
		}

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

			// render on a double buffer
			do {
				do {
					Graphics2D g = (Graphics2D) this.buffer.getDrawGraphics();
					g.addRenderingHints(Scene.RENDERING_HINTS);
					g.setFont(Fonts.DEFAULT);
					this.render(g);
					this.renderWidgets(g);
					g.dispose();
				// repeat if the rendering buffer contents were restored
				} while (this.buffer.contentsRestored() && running);
			// repeat if the drawing buffer contents were lost
			} while (this.buffer.contentsLost() && running);

			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
			}

			// update game and widgets
			this.update(Scene.DESIRED_DELTA_LOOP_NS - timeDiff);
			this.updateWidgets(Scene.DESIRED_DELTA_LOOP_NS - timeDiff);
			this.game.update(Scene.DESIRED_DELTA_LOOP_NS - timeDiff);

			afterTime = System.nanoTime();
			timeDiff = afterTime - beforeTime;
			sleepTime = (Scene.DESIRED_DELTA_LOOP_NS - timeDiff) - overSleepTime;


			// if sleep is needed (too fast)
			if (sleepTime > 0) {
				try {
					Thread.sleep(sleepTime/(1000*1000));
				} catch (InterruptedException ex) {
					// ex.printStackTrace();
				}

				overSleepTime = (System.nanoTime() - afterTime) - sleepTime;

			// if sleep is not needed (too slow)
			} else {
				overSleepTime = 0L;
				// if the thread has been late for too much time, give up
				// the cpu to other threads
				if (++noDelays >= Scene.NO_DELAYS_PER_YELD) {
					Thread.yield();
					noDelays = 0;
				}
			}

			if (this.threadPaused) {
				this.pauseLock.lock();
				this.threadResumed.awaitUninterruptibly();
				this.pauseLock.unlock();
			}
		}
	}

	/* 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;
		this.threadResumed.signal();
	}


	// 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.updateCanvasSize(this.getParent().getSize());
	}

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

		this.widgetAnchors.get(Widget.Anchor.SO).move(0, newSize.height);
		this.widgetAnchors.get(Widget.Anchor.S ).move(newSize.width / 2, newSize.height);
		this.widgetAnchors.get(Widget.Anchor.SE).move(newSize.width, newSize.height);
		this.widgetAnchors.get(Widget.Anchor.E ).move(newSize.width, newSize.width / 2);
		this.widgetAnchors.get(Widget.Anchor.NE).move(newSize.width, 0);
		this.widgetAnchors.get(Widget.Anchor.N ).move(newSize.width / 2, 0);
		// this.widgetAnchors.get(Widget.Anchor.NO).move(0, 0);
		this.widgetAnchors.get(Widget.Anchor.O ).move(0, newSize.height / 2);
	}

	/* 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) {
		for (Widget w : this.clickableWidgetsCache) {
			((Clickable) w).mouseClick(e.getPoint());
		}
	}

	@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) {}

}