/*
 * RollingCubes.java
 *      The RollingCubes game
 *      Usage:  <applet code="RollingCubes.class width=100 height=100>
 *              </applet>
 *
 * Ken Shirriff         ken.shirriff@eng.sun.com
 *
 * Copyright (c) 1996 Sun Microsystems, Inc. All Rights Reserved.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 *
 * Please refer to the file "license.txt"
 * for further important copyright and licensing information.
 */

import java.awt.*;
import java.awt.image.*;
import java.applet.Applet;

public class RollingCubes extends Applet implements Runnable {
	Button startButton = null;
	Label movetf = null;
	RCBoard board = null;
	GridBagLayout topGridbag;
	GridBagConstraints topGc;
	Thread thread= null;
	int moves;

	//Initialize everything
	public void init() {
		topGridbag = new GridBagLayout();
		topGc = new GridBagConstraints();
		setLayout(topGridbag);
		setBackground(new Color(198,216,255));
		setForeground(Color.black);
		board = new RCBoard();
		constrain(topGridbag, topGc, this, board,
			GridBagConstraints.REMAINDER);
		movetf = new Label("   0 moves");
		startButton = new Button("restart");
		constrain(topGridbag, topGc, this, movetf, 1);
		constrain(topGridbag, topGc, this, startButton,
			GridBagConstraints.REMAINDER);
		restart();
	}

	// Start a new game
	public void restart() {
		moves = 0;
		movetf.setText("   0 moves");
		if (thread != null) {
			thread.stop();
		}
		board.restart();
		thread = new Thread(this);
		thread.start();
	}

	// Helper function for GridBagLayout
        public void constrain(GridBagLayout gridbag, GridBagConstraints gc, Container parent, Component c, int w) {
                gc.gridwidth = w;
                gridbag.setConstraints(c,gc);
                parent.add(c);
        }


	// This is the main game loop.
	// It gets a player move until the player wins.
	public void run() {
		Point mv;
		while (true) {
			board.repaint();
			// Wait for player to move
			board.doplayermove();
			// See which way the move is going
			moves++;
			movetf.setText("   "+moves+(moves==1?"move":" moves"));
			if (board.win()) {
				// Player won
				board.winner();
				board.repaint();
				break;
			}
		}
	}

        public boolean action(Event e, Object o) {
                if (e.target.equals(startButton)) {
			restart();
		}
                return super.action(e,o);
        }
}

class RCBoard extends Canvas {

	int mousemode=0;
	int win=0;
	int margin=10;
	int sz=50;
	int thick=sz/2;
	int xpix=sz*3+2*margin;
	int ypix=sz*3+2*margin;
	Point mv = new Point(0,0);
	Color tcolors[] = {Color.gray,Color.gray,Color.gray,Color.gray,
		Color.black,Color.white,Color.lightGray};
	Color border = Color.blue;
	Thread waitthread;
	Image back = null;
	Graphics backgr;
	int data[][] = new int[3][3];
	int emptyx, emptyy;
	// The data specifies the direction of the black face of each cube.
	// The movetab specifies the new direction after a roll in the
	// given direction.
	final int N=0, S=1,E=2,W=3,TOP=4,BOT=5,EMPTY=6;
	int movetab[][] = {
		{BOT,TOP,E,W,N,S}, //Roll N
		{TOP,BOT,E,W,S,N}, //Roll S
		{N,S,BOT,TOP,E,W}, //Roll E
		{N,S,TOP,BOT,W,E} //Roll W
	};

	// Test if the board is in a winning position
	public boolean win() {
		for (int i=0;i<3;i++) {
			for (int j=0;j<3;j++) {
				if (i==1&&j==1) {
					if (data[i][j]!=EMPTY) {
						return false;
					}
				} else {
					if (data[i][j]!=BOT) {
						return false;
					}
				}
			}
		}
		return true;
	}


	// Restart the game by initializing everything
	public void restart() {
		tcolors[EMPTY]=getBackground();
		emptyx = 1;
		emptyy = 1;
		for (int i=0;i<3;i++) {
			for (int j=0;j<3;j++) {
				data[i][j] = TOP;
			}
		}
		data[emptyx][emptyy]=EMPTY;
		resize(xpix,ypix);
		win = 0;
		mousemode=0;
		rotating=0;
		repaint();
	}

	public void winner() {
		win = 1;
	}

	// This routine gets and processes the player's move
	public void doplayermove() {
		repaint();
		while (true) {
			mousemode=1;
			waitthread = Thread.currentThread();
			while (mousemode==1) {
				try {
					synchronized(waitthread) {
						waitthread.wait();
					}
				} catch (InterruptedException e) {};
			}
			if (processmove()) {
				return;
			}
		}
	}

	int rot_dir, rot_old, rot_new;
	int rotating = 0;

	boolean processmove() {
		int diffx = emptyx-mv.x;
		int diffy = emptyy-mv.y;
		if (diffx == 0) {
			if (diffy==-1) {
				rot_dir=N;
			} else if (diffy==1) {
				rot_dir=S;
			} else {
				return false;
			}
		} else if (diffx==1 || diffx==-1) {
			if (diffy==0) {
				rot_dir=(diffx==1)?E:W;
			} else {
				return false;
			}
		} else {
			return false;
		}

		rot_old = data[mv.x][mv.y];
		rot_new = movetab[rot_dir][rot_old];
		rotating=1;
		repaint();
		waitthread = Thread.currentThread();
		while (rotating != 0) {
			try {
				synchronized(waitthread) {
					waitthread.wait();
				}
			} catch (InterruptedException e) {};
		}
		// Update the data table
		data[emptyx][emptyy]=rot_new;
		emptyx = mv.x;
		emptyy = mv.y;
		data[emptyx][emptyy]=EMPTY;
		return true;
	}

	double alpha;

	void rotate(Graphics g) {
		// Do a cool rotate effect
		int x0=margin+mv.x*sz;
		int y0=margin+mv.y*sz;
		int x1=margin+emptyx*sz;
		int y1=margin+emptyy*sz;
		int sina = (int)(Math.sin(alpha)*sz);
		int cosa = (int)(Math.cos(alpha)*sz);
		g.setColor(tcolors[EMPTY]);
		if (rot_dir==N) {
			g.fillRect(x0+1,y0+cosa+1,sz-1,sz-cosa-1);
			drawbox(g,x0,y0-sina,sz,cosa,rot_old);
			drawbox(g,x0,y0-sina+cosa,sz,sina,rot_new);
		} else if (rot_dir==S) {
			g.fillRect(x0+1,y0+1,sz-1,sz-cosa-1);
			drawbox(g,x0,y0+sz-cosa+sina,sz,cosa,rot_old);
			drawbox(g,x0,y0+sz-cosa,sz,sina,rot_new);
		} else if (rot_dir==E) {
			g.fillRect(x0+1,y0+1,sz-cosa-1,sz-1);
			drawbox(g,x0+sz-cosa+sina,y0,cosa,sz,rot_old);
			drawbox(g,x0+sz-cosa,y0,sina,sz,rot_new);
		} else if (rot_dir==W) {
			g.fillRect(x0+cosa,y0+1,sz-cosa,sz-1);
			drawbox(g,x0-sina,y0,cosa,sz,rot_old);
			drawbox(g,x0-sina+cosa,y0,sina,sz,rot_new);
		}
		alpha += .15;
		if (alpha>3.14159/2) {
			rotating=0;
			synchronized(waitthread) {
				waitthread.notify();
			}
		}
		repaint();
		pause(30);
	}

public boolean mouseDown(Event evt, int xm, int ym) {
	int x = (xm-margin)/sz;
	int y = (ym-margin)/sz;
	if (mousemode==1 && x>=0 && x<3 && y>=0 && y<3) {
		mv.x = x;
			mv.y = y;
			mousemode=0;
			synchronized(waitthread) {
				waitthread.notify();
			}
		}
		return true;
	}

	public void update(Graphics g) {
		if (back == null) {
			back = createImage(xpix,ypix);
			backgr = back.getGraphics();
			backgr.setColor(getBackground());
			backgr.fillRect(0,0,xpix,ypix);
		}
		if (rotating==1) {
			paint(backgr);
			alpha=0;
			rotating=2;
		}
		if (rotating==2) {
			rotate(backgr);
		} else if (rotating==0) {
			paint(backgr);
		}
		g.drawImage(back,0,0,this);
	}

	// Draw the box at the specified position
        void drawbox(Graphics g, int x0, int y0, int w, int h, int dir) {
		if (dir==TOP || dir==BOT || dir==EMPTY) {
			g.setColor(tcolors[dir]);
			g.fillRect(x0,y0,w,h);
		} else if (dir==N || dir==S) {
                        g.setColor(dir==N?Color.black:Color.white);
                        g.fillRect(x0,y0,w,h/2);
                        g.setColor(dir==S?Color.black:Color.white);
                        g.fillRect(x0,y0+(h-h/2),w,h/2);

                } else if (dir==E || dir==W) {
                        g.setColor(dir==W?Color.black:Color.white);
                        g.fillRect(x0,y0,w/2,h);
                        g.setColor(dir==E?Color.black:Color.white);
                        g.fillRect(x0+(w-w/2),y0,w/2,h);
		}
                g.setColor(border); 
                g.drawRect(x0,y0,w,h);
        }


	public void paint(Graphics g) {
		for (int i=0;i<3;i++) {
			for (int j=0;j<3;j++) {
				drawbox(g,margin+sz*i,margin+sz*j,sz,sz,data[i][j]);
			}
		}
		if (win==1) {
			g.setColor(Color.white);
			g.fillRect(margin+1,margin+1,xpix-2*margin,20);
			g.setColor(Color.red);
			g.drawString("Congratulations!  You win!",margin+2,margin+15);
		}
	}

	// Pause for n ms
	public void pause(int n) {
		try {
			Thread.currentThread().sleep(n);
		} catch (InterruptedException e) {}
	}

}