import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.applet.*;
import java.util.*;

public class VirtualCondensation extends Applet 
implements Runnable,MouseListener,MouseMotionListener {
	
	int width,height;
	int[] pixels;
	MemoryImageSource mis;
	Image background;
	Image image;
	Image offscreen;
	Graphics og;
	Thread thread;
	int[][] canal;
	int x0,y0;
	int radius;
	
    public void init() {
		width = getSize().width;
		height = getSize().height;
		background = 
			getImage(getDocumentBase(),"background.jpg")
			.getScaledInstance(width,height,Image.SCALE_DEFAULT);
		try {
			PixelGrabber pg = new PixelGrabber(
				getImage(getDocumentBase(),"mist.jpg")
				.getScaledInstance(width,height,Image.SCALE_DEFAULT),
				0,0,width,height,true);
			pg.grabPixels();
			pixels = (int[])pg.getPixels();
		} catch (InterruptedException e) {
			e.printStackTrace();
			pixels = new int[width*height];
		}
		mis = new MemoryImageSource(width,height,pixels,0,width);
		mis.setAnimated(true);
		image = createImage(mis);
		canal = new int[height][width];
		for (int y=0;y<height;y++)
			for (int x=0;x<width;x++) {
				canal[y][x] = 0;
			}
		radius = 6;
		addMouseListener(this);
		addMouseMotionListener(this);
		newPixels(0,0,width,height);
    }
	
	public synchronized void start() {
		if (thread==null) {
			thread = new Thread(this);
			thread.setDaemon(true);
			thread.start();
		}
	}
	
	public synchronized void stop() {
		if (thread!=null) {
			thread.interrupt();
			try {
				thread.join();
			} catch (InterruptedException e) {
			}
			thread = null;
		}
	}
	
	public void run() {
		Random random = new Random();
		while (!Thread.interrupted()) {
			for (int t=0;t<4;t++) synchronized (this) {
				int x = Math.abs(random.nextInt())%width;
				int y = Math.abs(random.nextInt())%height;
				boolean forward = random.nextInt()>0;
				boolean turned = false;
				int drop = canal[y][x];
				for (;;) {
					if (y==height-1) {
						break;
					} else if (canal[y+1][x]>=drop) {
						y++;
						drop = canal[y][x];
						turned = false;
					} else if (forward) {
						if (x<width-1 && canal[y][x+1]>=drop) {
							x++;
							drop = canal[y][x];
						} else if (!turned) {
							turned = true;
							forward = false;
						} else {
							break;
						}
					} else {
						if (x>0 && canal[y][x-1]>=drop) {
							x--;
							drop = canal[y][x];
						} else if (!turned) {
							turned = true;
							forward = true;
						} else {
							break;
						}
					}
				}
				if (Math.abs(random.nextInt())%255<drop) {
					while (++y<height && canal[y][x]<=drop/2) {
						canal[y][x] = drop;
					}
				}
			}
			synchronized (this) {
				for (int y=0;y<height;y++)
					for (int x=0;x<width;x++) {
						canal[y][x] = Math.max(canal[y][x]-4,0);
					}
				newPixels(0,0,width,height);
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				break;
			}
		}
	}
	
	synchronized void newPixels(int x0,int y0,int w,int h) {
		for (int y=y0;y<y0+h;y++)
			for (int x=x0;x<x0+w;x++) {
				pixels[y*width+x] = 
					(255-canal[y][x])<<24|pixels[y*width+x]&0xffffff;
			}
		mis.newPixels(x0,y0,w,h);
		repaint(x0,y0,w,h);
	}
	
	public synchronized void mousePressed(MouseEvent e) {
		x0 = e.getX();
		y0 = e.getY();
		int xmin = Math.max(0,x0-radius);
		int xmax = Math.min(x0+radius,width);
		int ymin = Math.max(0,y0-radius);
		int ymax = Math.min(y0+radius,height);
		for (int y=ymin;y<ymax;y++)
			for (int x=xmin;x<xmax;x++) {
				int dx = x-x0;
				int dy = y-y0;
				if (dx*dx+dy*dy<radius*radius) canal[y][x] = 255;
			}
		newPixels(xmin,ymin,xmax-xmin,ymax-ymin);
	}
	
	public void mouseReleased(MouseEvent e) {
	}
	
	public void mouseEntered(MouseEvent e) {
	}
	
	public void mouseExited(MouseEvent e) {
	}
	
	public void mouseClicked(MouseEvent e) {
	}
	
	public synchronized void mouseDragged(MouseEvent e) {
		int x1 = e.getX();
		int y1 = e.getY();
		int nx = x1-x0;
		int ny = y1-y0;
		int n2 = nx*nx+ny*ny;
		int xmin = Math.max(0,Math.min(x0,x1)-radius);
		int xmax = Math.min(Math.max(x0,x1)+radius,width);
		int ymin = Math.max(0,Math.min(y0,y1)-radius);
		int ymax = Math.min(Math.max(y0,y1)+radius,height);
		for (int y=ymin;y<ymax;y++)
			for (int x=xmin;x<xmax;x++) {
				int dx = x-x0;
				int dy = y-y0;
				int dn = dx*nx+dy*ny;
				if (dn*dn>0) {
					if (dn*dn<n2*n2) {
						dx -= dn*nx/n2;
						dy -= dn*ny/n2;
					} else {
						dx = x-x1;
						dy = y-y1;
					}
				}
				if (dx*dx+dy*dy<radius*radius) canal[y][x] = 255;
			}
		x0 = x1;
		y0 = y1;
		newPixels(xmin,ymin,xmax-xmin,ymax-ymin);
	}
	
	public void mouseMoved(MouseEvent e) {
	}
	
    public void update(Graphics g) {
		paint(g);
    }
	
    public synchronized void paint(Graphics g) {
		if (offscreen==null) {
			offscreen = createImage(width,height);
			og = offscreen.getGraphics();
		}
		og.drawImage(background,0,0,this);
		og.drawImage(image,0,0,this);
		g.drawImage(offscreen,0,0,this);
    }
}