// Moving Sprites by Hiroyuki Murata
package mypkg;
import java.awt.*;
import java.awt.image.*;

public class Sprites extends java.applet.Applet implements Runnable{

	final String AppInfo = "Moving Sprites ver0.5 by Hiroyuki Murata";
	final String imagefile = "8ken_bw.gif";
	final int N=8, SpWidth=32;
	final Font fontFix = new Font("TimesRoman",Font.ITALIC,20);
	final Font fontApp = new Font("TimesRoman",Font.ITALIC,36);
	final int colors[] = {
		0xff0000,
		0x00ff00,
		0x0000ff,
		0xffff00,
		0x00ffff,
		0xff00ff,
		0xff8000,
		0x00ff80,
		0x8000ff
	};

	Thread thread;
	MediaTracker tracker;
	Image sprite[] = new Image[N];
	Motion mv[] = new Motion[N];
	int interval;
	int offsetB;	// x-offset of Front,Background
	int size_w,size_h;

	Image    iA;
	Graphics gA;
	Toolkit  tk;
	boolean
		CalledByUpdate,// (set in update())
		loadedB,		// loaded on backbround
		loadedF,		// loaded on front
		loaded_every,	// loaded on every sprites & background
		loading_displayed,	// "loading..." displayed
		sleep_enable	// sleep(interval) enable
	;

	public String getAppletInfo() {
		return AppInfo;
	}

	//---------------------------------------------------------------------
	public void init(){
		loadedB = loadedF = loaded_every =
		 CalledByUpdate = loading_displayed = false;
		sleep_enable = false;

		tracker = new MediaTracker(this);

		String param = getParameter("interval");
		interval = (param != null) ? Integer.parseInt(param) : 100;
		size_w = size().width;
		size_h = size().height;
		offsetB = size_w;

		tk = getToolkit();
		iA = createImage(offsetB+size_w,size_h);
		gA = iA.getGraphics();
		gA.setColor(Color.pink);
		gA.fillRect(offsetB,0,size_w,size_h);
		gA.setColor(Color.cyan);
		gA.fillRect(0,0,size_w,size_h);

		Image allsprite = getImage(getDocumentBase(), imagefile);
		ImageProducer imgSrc = allsprite.getSource();

		for (int i=0; i<N; i++) {
			ImageFilter CrpFlt = new CropImageFilter(i*SpWidth,0, SpWidth,32);
			ImageProducer CrpSrc = new FilteredImageSource(imgSrc,CrpFlt);
			MyFilter MyFlt = new MyFilter(colors[i]);
			ImageProducer imgPrd = new FilteredImageSource(CrpSrc,MyFlt);
			sprite[i] = createImage(imgPrd);
			tracker.addImage(sprite[i], 1);
			mv[i] = new Motion(32,32,size_w,size_h);
		}

		setFont(fontApp);
	}

	public void start(){
		if(thread == null){
			thread = new Thread(this);
			thread.start();
		}
	}

	public void stop(){
		if (thread != null) {
			thread.stop();
			thread = null;
		}
	}

	//---------------------------------------------------------------------
	public void run(){
		try{
			tracker.waitForAll();
		}catch (InterruptedException e) {
			return;
		}

		Thread me = Thread.currentThread();

		if(!loadedB){
			if(thread==me){
				repaint();
			}
			createBackground();
			loadedB = true;
		}

		me.setPriority(Thread.MIN_PRIORITY);

		while(thread==me){
			try{
				if(sleep_enable){
					Thread.sleep(interval);
				}else{
					Thread.sleep(10);
				}
			}catch (InterruptedException e) {
				break;
			}
			repaint();
		}
	}

	void createBackground(){
		int pw=128, ph=128;
		int pix[] = new int[pw * ph];
		int index = 0;

		for(int y=0; y<ph; y++){
			int gre = y * 256 / ph;
			for(int x=0; x<pw; x++){
				int red = x * 256 / pw;
				int blu = 255 - ((red+gre)/2);
				pix[index++] = (255<<24) | (red<<16) | (gre<<8) | blu;
			}
		}

		Image img = createImage(new MemoryImageSource(
			pw,ph, ColorModel.getRGBdefault(), pix, 0,pw
		));

		for(int y=0; y<size_h; y+=ph){
			for(int x=0; x<size_w; x+=pw){
				gA.drawImage(img,offsetB+x,y,this);
				tk.sync();
			}
		}

		gA.setColor(Color.black);
		gA.setFont(fontFix);
		FontMetrics metricsFix = getFontMetrics(fontFix);
		int xFix = offsetB+size_w - metricsFix.stringWidth(AppInfo) - 10;
		int yFix =         size_h - metricsFix.getDescent()         - 3;
		gA.drawString(AppInfo,xFix,yFix);
		tk.sync();
	}

	//---------------------------------------------------------------------
	public void update(Graphics g){
		CalledByUpdate = true;
		paint(g);
	}

	public void paint(Graphics g){
	    g.clipRect(0,0,size_w,size_h);
		//tk.sync();
		//System.gc();
		if(tracker.isErrorAny()){
			g.setColor(Color.red);
			g.drawString("Error!",40,120);
			return;
		}

		if(CalledByUpdate){
			paintF();
			paintO(g);
			CalledByUpdate = false;
		}else{
			paintO(g);
		}
	}

	void paintF(){
		if(loaded_every){
			for(int i=0; i<N; i++){
				mv[i].step();
				gA.copyArea(
					offsetB+mv[i].x0, mv[i].y0,
					mv[i].fw, mv[i].fh,
					-size_w, 0
				);
			}
		}else{
			gA.copyArea(
				offsetB, 0,
				size_w, size_h,
				-size_w, 0
			);
		}

		for(int i=0; i<N; i++){
			if(loaded_every){
				gA.drawImage(sprite[i], mv[i].x1, mv[i].y1, this);
				loadedF = true;
			}else if(tracker.checkAll() && loadedB){
				loaded_every = true;
			}
		}
	}

	void paintO(Graphics g){
		if(CalledByUpdate && loadedF && !loading_displayed){
			for(int i=0; i<N; i++){
				Graphics gcO =  g.create(mv[i].mix, mv[i].miy, mv[i].maw, mv[i].mah);
				gcO.drawImage(iA, -mv[i].mix, -mv[i].miy, this);
				gcO.dispose();
			}
		}else{
			loading_displayed = false;
			g.drawImage(iA, 0, 0, this);
		}
		if(!loadedF){
			g.drawString("loading...",40,80);
			loading_displayed = true;
		}
	}

	Color rndcol(){
		return new Color(
			(int)(Math.random()*256.0),
			(int)(Math.random()*256.0),
			(int)(Math.random()*256.0)
		);
	}

	public boolean mouseDown(Event evt, int x, int y) {
		sleep_enable = !sleep_enable;
		return true;
	}
}

/*************************************************************************/
class Motion{

	public int	x0,y0,	// old position
				x1,y1,	// new position
				fw,fh,	// foreground width,height
				mix,miy,// minimum x,y
				maw,mah;// maximum w,h

	int	bw,bh,	// background width,height
		max,may,// x,y area maximum
		vx,vy,	// x,y velocity
		ax,ay,	// x,y absolute velocity
		dx,dy;	// x,y direction

	Motion(int fw, int fh, int bw, int bh){
		this.fw = fw;
		this.fh = fh;
		this.bw = bw;
		this.bh = bh;
		max = bw - fw;
		may = bh - fh;
		dx = rnddir();
		dy = rnddir();
		rndvel();
		x0 = y0 = mix = miy = 0;
		x1 = (int)(Math.random()*(float)max);
		y1 = (int)(Math.random()*(float)may);
		maw = bw;
		mah = bh;
	}

	int rnddir(){
		int ret = (int)(Math.random()*2.0);
		if(ret==0)	ret = -1;
		return ret;
	}

	void rndvel(){
		ax = 3 + (int)(Math.random()*10.0);
		ay = 3 + (int)(Math.random()*10.0);
		vx = ax * dx;
		vy = ay * dy;
	}

	public void step(){
		x0 = x1;	x1 += vx;
		y0 = y1;	y1 += vy;
		if( (x1<0) || (max<=x1) ){
			if(x1<0){ x1 = -x1; }
			else    { x1 = 2*max - x1 - 1;}
			dx = -dx;
			rndvel();
		}
		if( (y1<0) || (may<=y1) ){
			if(y1<0){ y1 = -y1; }
			else    { y1 = 2*may - y1 - 1;}
			dy = -dy;
			rndvel();
		}

		if(x0<=x1){ mix = x0;  maw = fw + (x1 - x0);}
		else      { mix = x1;  maw = fw + (x0 - x1);}

		if(y0<=y1){ miy = y0;  mah = fh + (y1 - y0);}
		else      { miy = y1;  mah = fh + (y0 - y1);}
	}
}

/*************************************************************************/
class MyFilter extends RGBImageFilter {
	int tgt;

	public MyFilter(int rgb) {
		tgt = rgb | 0xff000000;
		canFilterIndexColorModel = true;
	}

	/**
	 * java.awt.image.RGBImageFilter stuff
	 */
	public int filterRGB(int x, int y, int rgb){
		int ret = 0x00000000;
		if((rgb & 0x00808080) == 0){
			ret = tgt;
		}
		return ret;
	}
}

/*************************************************************************/