/*
 * Islet ICP'98 demonstation
 * Redistribution permitted under the terms of GNU General Public License version 2
 *  "ftp://prep.ai.mit.edu/pub/gnu/GPL"
 * Author: Jan Kratochvil <short@ucw.cz> (no flames for this piece of crap, please)
 */

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

public class Islet extends Applet
{
Applet app=this;

	private interface ImageLoader
	{ public Image load(String name); }

	static private class CmdLoader implements ImageLoader
	{
		Toolkit kit;
		public CmdLoader(Toolkit _kit) { kit=_kit; }
		public Image load(String name) { return(kit.getImage(name)); }
	}

	private class AppLoader implements ImageLoader
	{ public Image load(String name) { return(app.getImage(app.getCodeBase(),name)); } }

	private class AppListener extends MouseAdapter implements MouseListener
	{
		public void mouseClicked(MouseEvent e)
		{ new IsletThread(false,new AppLoader()); }
	}

	public void paint(Graphics g)
	{
		super.paint(g);
		g.setColor(new Color(100,255,100));
		g.fill3DRect(0,0,getSize().width-1,getSize().height-1,true);
		g.setColor(Color.black);
		g.setFont(new Font("Courier",Font.BOLD,getSize().height*8/10));
		g.drawString("Open demo window",getSize().height*2/10,getSize().height*8/10);
	}

	public void update(Graphics g)
	{ paint(g); } //Leave background garbaged

	public void init()
	{ addMouseListener(new AppListener()); }

	public String getAppletInfo()
	{
		return(
			"Islet by Jan Kratochvil <short@ucw.cz> in 1998. Created for purposes of ICP'98 competition.\n"+
			"Redistribution permitted under GNU General Public License (AKA GPL) version 2 (exactly) found on ftp://prep.ai.mit.edu/pub/gnu/GPL."
			);
	}

	static public void main(String[] args)
	{ new IsletThread(true,new CmdLoader(Toolkit.getDefaultToolkit())); }

static private class IntBugCheck extends Thread
{
Thread t;

	public IntBugCheck(Thread _t)
	{
		t=_t;
		setDaemon(true);
		start();
	}
	
	public void run()
	{
		try { sleep(30); }
		catch (InterruptedException e) {}
		t.interrupt();
	}
}

//! Indentation violation:
static private class IsletThread extends Thread
{
boolean doexit;
Frame fview,fcontrol;
Imager img;
View view;
ScrollPane viewpane;
FieldWater water;
boolean prepared=false;
Point mousefld=new Point(-1,-1);
boolean mousefldok=false;
byte tool;
ToolBox tools[];
ImageLoader imageloader;
TimerQ timerq=new TimerQ();
static final int deltax[]={0,1,0,-1},deltay[]={-1,0,1,0};
boolean running=false;
ERandom rnd=new ERandom();
int fldcnt[];
Vector fld=new Vector(); //synchronized inside View!
final long buggywait=200;

	private Vector getfld(int y)
	{ return((Vector)fld.elementAt(y)); }
	private Field getfld(Point pt)
	{ return((Field)(getfld(pt.y).elementAt(pt.x))); }
	private Field getfld(int x,int y)
	{ return(getfld(new Point(x,y))); }
	private void setfld(int y,Vector v)
	{ fld.setElementAt(v,y); }
	private void setfld(Point pt,Field f)
	{ getfld(pt.y).setElementAt(f,pt.x); }
	private void setfld(int x,int y,Field f)
	{ setfld(new Point(x,y),f); }

	private class ERandom extends Random
	{
		public int nextUInt()
		{ return(Math.abs(nextInt())); }
	}

	private class Timer
	{
	public long when;
	public Field trig;

		public Timer(long ms,Field _trig)
		{
			when=System.currentTimeMillis()+ms;
			trig=_trig;
			timerq.add(this);
		}
	}

	private class TimerQ
	{
	Vector q=new Vector();

		synchronized public void add(Timer tm)
		{
			int i;
			for (i=0;i<q.size();i++)
				if (((Timer)q.elementAt(i)).when>=tm.when) break;
			q.insertElementAt(tm,i);
			interrupt();
		}

		public void runday()
		{ new Timer(1000,null); }

		synchronized public long getMin()
		{
			while (!q.isEmpty()) {
				Timer t=(Timer)q.firstElement();
				if (t.when>System.currentTimeMillis()) break;
				Field f=t.trig;
				q.removeElementAt(0);
				if (f!=null) {
					view.kickRobotAss(f);
					continue;
					}
				runday();
				if (daytime.val+1<daytime.getMax()) {
					daytime.inc();
					continue;
					}
				daybox.setState(pertp);
				dayboxdog.itemStateChanged(null);
				}
			if (q.isEmpty()) return(Long.MAX_VALUE);
			return(Math.max(0,((Timer)q.firstElement()).when-System.currentTimeMillis()));
		}

		synchronized public void clear()
			{ q.removeAllElements(); }
	}

	private class Rotator extends ImageFilter
	{// "Insipired" by Sun's RotateFilter
		int imgh;

		public void setDimensions(int width,int height)
		{  consumer.setDimensions((imgh=height),width); }

		public void setProperties(Hashtable p)
		{
			p=(Hashtable)p.clone();
			Object s=p.get("filters");
			if (s==null) p.put("filters",toString());
			else if (s instanceof String)
				p.put("filters",((String)s)+toString());
			consumer.setProperties(p);
		}

		public void setHints(int flg)
		{ consumer.setHints(flg&(SINGLEFRAME|SINGLEPASS)); } //RANDOMPIXELORDER?

		public void setPixels(int x1,int y1,int w,int h,ColorModel model,byte pixels[],int off,int scansize)
		{
			byte out[]=new byte[w*h];
			int dst=0;
			for (int y=0;y<h;y++) {
				for (int x=0;x<w;x++)
					out[x*h+h-1-y]=pixels[off++];
				off+=scansize-w;
				}
			consumer.setPixels(imgh-y1-h,x1,h,w,model,out,0,h);
		}

		public void setPixels(int x1,int y1,int w,int h,ColorModel model,int pixels[],int off,int scansize)
		{
			int out[]=new int[w*h];
			int dst=0;
			for (int y=0;y<h;y++) {
				for (int x=0;x<w;x++)
					out[x*h+h-1-y]=pixels[off++];
				off+=scansize-w;
				}
			consumer.setPixels(imgh-y1-h,x1,h,w,model,out,0,h);
		}
	}

	private class Imager
	{
	final String names[]={"water","land","wall","food","robotx","roboty"};
	public final byte WATER =0;
	public final byte LAND  =1;
	public final byte WALL  =2;
	public final byte FOOD  =3;
	public final byte ROBOTX=4;
	public final byte ROBOTY=5;
	public final byte MAXR =(byte)names.length;
	public final byte MAX  =(byte)((int)MAXR+2*3);
	public final byte sizex=16,sizey=16;
	public Image a[]=new Image[MAX];

		public Imager(ImageLoader loader)
		{
			tool=LAND;
			tools=new ToolBox[MAXR];
			fldcnt=new int[MAX];
			water=new FieldWater(0,0);
			for (byte i=0;i<MAXR;i++) {
				a[i]=loader.load(names[i]+".gif");
				(tools[i]=new ToolBox(i)).addMouseListener(tools[i]);
				}
			Rotator rotator=new Rotator();
			Toolkit kit=Toolkit.getDefaultToolkit();
			for (byte i=2;i<=6;i+=2)
			for (byte j=0;j<=1;j++)
				a[ROBOTX+i+j]=kit.createImage(new FilteredImageSource(a[ROBOTX+i-2+j].getSource(),rotator));
		}
		public void draw(Graphics g,byte tp,Point pt,Color col,ImageObserver obs)
		{
			g.drawImage(a[tp],pt.x,pt.y,sizex,sizey,obs);
			if (col!=null) {
				g.setColor(col);
				g.draw3DRect(pt.x,pt.y,sizex-1,sizey-1,true);
			}
		}
	}

	private abstract class Field
	{
		public Point pt;
		protected byte tp;

		public Field(Point _pt)
		{
			pt=new Point(_pt);
		}
		private void shiftBy(int how)
		{
			fldcnt[tp]+=how;
			switch (tp) {
			case img.FOOD:   foodcnt.setCount(fldcnt[tp]); break;
			case img.ROBOTX: sidex  .setCount(fldcnt[tp]); break;
			case img.ROBOTY: sidey  .setCount(fldcnt[tp]); break;
			}
		}
		public void setup(byte _tp)
		{
			tp=_tp;
			shiftBy(+1);
			if (running) addTimer();
		}

		public Point cellPt(Point _pt)
		{ return(new Point(_pt.x*img.sizex,_pt.y*img.sizey)); }
		public Point cellPt(int x,int y)
		{ return(cellPt(new Point(x,y))); }
		public Point cellPt()
		{ return(cellPt(pt)); }
		public Rectangle cellRect()
		{	Point npt=cellPt();
			return(new Rectangle(npt.x,npt.y,img.sizex,img.sizey));
		}

		public Point whichCell(Point _pt)
		{
			Point p=new Point(_pt);
			p.x/=img.sizex;
			p.y/=img.sizey;
			if (!view.validateFld(p)) return(new Point(-1,-1));
			return(p);
		}

		public void paint()
		{
			Rectangle r=cellRect();
			view.repaint(r.x,r.y,r.width,r.height);
		}

		public void moveYourAss() {}
		public void addTimer() {}
		public void dispose()
		{ shiftBy(-1); pt=null; }
		public byte getValue() { return(tp); }
		public byte getImgValue() { return(getValue()); }
		public boolean isRobot() { return(tp==img.ROBOTX || tp==img.ROBOTY); }
		public Field create(Point _pt,byte _tp)
		{
			switch (_tp) {
			case img.WATER:  return(new FieldWater (_pt));
			case img.LAND:   return(new FieldLand  (_pt));
			case img.WALL:   return(new FieldWall  (_pt));
			case img.FOOD:   return(new FieldFood  (_pt));
			case img.ROBOTX: return(new FieldRobotX(_pt));
			case img.ROBOTY: return(new FieldRobotY(_pt));
			default: return(null);
			}
		}
		public Field create(int x,int y,byte _tp)
		{ return(create(new Point(x,y),_tp)); }
	}

	private class FieldWater extends Field
	{ public FieldWater (Point _pt) { super(_pt); setup(img.WATER);  } public FieldWater (int x,int y) { this(new Point(x,y)); } }
	private class FieldLand extends Field
	{ public FieldLand  (Point _pt) { super(_pt); setup(img.LAND);   } public FieldLand  (int x,int y) { this(new Point(x,y)); } }
	private class FieldWall extends Field
	{ public FieldWall  (Point _pt) { super(_pt); setup(img.WALL);   } public FieldWall  (int x,int y) { this(new Point(x,y)); } }
	private class FieldFood extends Field
	{ public FieldFood  (Point _pt) { super(_pt); setup(img.FOOD);   } public FieldFood  (int x,int y) { this(new Point(x,y)); } }

	private class FieldRobot extends Field
	{
	byte orient;
	Side side;
	float weight;

		private void reorient(boolean full)
		{
			byte oo=orient;
			orient=(byte)(rnd.nextUInt()%(full?4:3));
			if (full) return;
			if (orient==oo) orient=3;
			this.paint();
		}
		private void reorient() { reorient(false); }
		public FieldRobot(Point _pt,boolean wh)
		{
			super(_pt);
			weight=1;
			reorient(true);
			side=(wh?sidey:sidex);
		}

		private void spawn(FieldRobot r)
		{
			Field f;
			if (r.weight<2)  f=new FieldLand(pt);
			else {
				if (r.side.wh) f=new FieldRobotY(pt);
				else           f=new FieldRobotX(pt);
				((FieldRobot)f).orient=orient;
				r.weight-=1;
				}
			setfld(pt,f); f.paint();
		}

		public byte getImgValue() { return((byte)(getValue()+2*orient)); }
		public void addTimer()
		{
			new Timer(10000/Math.max(1,side.speed.val),this);
		}
		public void moveYourAss()
		{
			if (pt==null || (pertp && !side.wh)) return;
			addTimer();
			Point npt=new Point(pt.x+deltax[orient],pt.y+deltay[orient]);
			if (!view.validateFld(npt)) { reorient(); return; }
			Field f=getfld(npt);
			switch (f.getValue()) {
			case img.WATER:
			case img.WALL:
				reorient(); return;
			case img.LAND:
				break;
			case img.FOOD:
				weight+=((float)foodwght.val)/100;
				break;
			case img.ROBOTX:
			case img.ROBOTY:
				FieldRobot r=(FieldRobot)f;
				if (r.side.wh==side.wh) { reorient(); return; }
				if (((pertp?fightnight.val:fightday.val)>(rnd.nextUInt()%100))==side.wh) { //we won
					weight+=r.weight;
					break;
					}
				r.weight+=weight;
				r.orient=(byte)(orient^2);
				r.paint();
				spawn(r);
				dispose();
				return;
			}
			setfld(npt,this);
			f.dispose();
			spawn(this);
			pt=npt;
			this.paint();
		}
	}
	private class FieldRobotX extends FieldRobot
	{ public FieldRobotX(Point _pt) { super(_pt,false); setup(img.ROBOTX); } public FieldRobotX(int x,int y) { this(new Point(x,y)); } }
	private class FieldRobotY extends FieldRobot
	{ public FieldRobotY(Point _pt) { super(_pt,true ); setup(img.ROBOTY); } public FieldRobotY(int x,int y) { this(new Point(x,y)); } }

	public IsletThread(boolean _doexit,ImageLoader _imageloader)
	{
		doexit=_doexit;
		imageloader=_imageloader;
		start();
	}

	private class View extends Panel implements MouseListener,MouseMotionListener,AdjustmentListener
	{
		synchronized public void paint(Graphics g)
		{
			if (!prepared) return;
			Rectangle r=g.getClipBounds();
			Point pt;
			view.validateFld(pt=new Point(r.x/img.sizex,r.y/img.sizey));
			int x=pt.x,y=pt.y;
			view.validateFld(pt=new Point((r.x+r.width -1)/img.sizex,(r.y+r.height-1)/img.sizey));
			int xm=pt.x,ym=pt.y;
			for (;y<=ym;y++) {
				Vector v=getfld(y);
				for (int xw=x;xw<=xm;xw++) {
					Field f=(Field)v.elementAt(xw);
					img.draw(g,f.getImgValue(),f.cellPt(),(xw==mousefld.x && y==mousefld.y?Color.black:null),this);
					}
				}
		}
		public void update(Graphics g)
		{ paint(g); } //Leave background garbaged

		synchronized public void kickRobotAss(Field f)
		{ f.moveYourAss(); }

		public boolean validateFld(Point pt)
		{
			boolean v=true;
			if (pt.x>=sizex.val) { pt.x=sizex.val-1; v=false; }
			if (pt.y>=sizey.val) { pt.y=sizey.val-1; v=false; }
			if (pt.x<0) { pt.x=0; v=false; }
			if (pt.y<0) { pt.y=0; v=false; }
			return(v);
		}

		synchronized public Point getAnyFld(byte tp)
		{
			if (fldcnt[tp]<=0) return(null);
			int skip=rnd.nextUInt()%fldcnt[tp],x=0,y=0;
			while (skip>=0 && y<sizey.val) {
				Vector v=getfld(y);
				while (x<sizex.val) {
					Field f=(Field)v.elementAt(x);
					if (f.getValue()==tp)
						if (--skip<=0) break;
					x++;
					}
				if (x>=sizex.val) { x=0; y++; }
				}
			if (skip>0) return(null); //Shouldn't happen!
			return(new Point(x,y));
		}

		synchronized public void mousePressed (MouseEvent e)
		{
			mouseMoved(e);
			if (!mousefldok) return;
			Field f=getfld(mousefld),fnew;
			if (f.getValue()==tool) return;
			setfld(mousefld,(fnew=water.create(mousefld,tool)));
			f.dispose();
			fnew.paint();
		}

		synchronized public void paintAt(Point pt)
		{
			if (mousefldok)
				getfld(mousefld).paint();
		}

		synchronized public void fldupdate(Point pt)
		{
			if (pt.equals(mousefld)) return;
			paintAt(mousefld);
			mousefld=pt;
			mousefldok=view.validateFld(new Point(mousefld));
			paintAt(mousefld);
		}

		public void mouseClicked (MouseEvent e) {}
		public void mouseEntered (MouseEvent e) {}
		public void mouseReleased(MouseEvent e) {}
		public void mouseExited  (MouseEvent e)
		{ fldupdate(new Point(-1,-1)); }
		public void mouseDragged (MouseEvent e)
		{ mousePressed(e); }
		public void mouseMoved   (MouseEvent e)
		{ fldupdate(water.whichCell(e.getPoint())); }

		public Dimension getPreferredSize()
		{ Point pt=water.cellPt(sizex.val,sizey.val);
			return(new Dimension(pt.x,pt.y));
			}
		public Dimension getMinimumSize()
		{ return(getPreferredSize()); }

		synchronized public void adjustmentValueChanged(AdjustmentEvent e)
		{
		int x,y,xval,xnewval,yval,ynewval;

			if (sizex==null || sizey==null) return;
			xval=sizex.val; xnewval=sizex.newval;
			yval=sizey.val; ynewval=sizey.newval;
			if (xval>xnewval) sizex.val=xnewval;
			if (yval>ynewval) sizey.val=ynewval;
			if (xval>xnewval)
				for (y=0;y<yval;y++) {
					for (x=xnewval;x<xval;x++)
						getfld(x,y).dispose();
					getfld(y).setSize(xnewval);
					}
			else if (xval<xnewval)
				for (y=0;y<yval;y++) {
					getfld(y).setSize(xnewval);
					for (x=xval;x<xnewval;x++)
						setfld(x,y,new FieldWater(x,y));
					}
			if (yval>ynewval) {
				for (y=ynewval;y<yval;y++)
					for (x=0;x<xnewval;x++)
						getfld(x,y).dispose();
				fld.setSize(ynewval);
				}
			else if (yval<ynewval) {
				fld.setSize(ynewval);
				for (y=yval;y<ynewval;y++) {
					setfld(y,new Vector(xnewval));
					getfld(y).setSize(xnewval);
					for (x=0;x<xnewval;x++)
						setfld(x,y,new FieldWater(x,y));
					}
				}
			sizex.val=xnewval;
			sizey.val=ynewval;
			Point pt2=water.cellPt(xnewval,ynewval);
			if (xval<xnewval) {
				Point pt1=water.cellPt(xval,0);
				view.repaint(pt1.x,pt1.y,pt2.x-pt1.x,pt2.y-pt1.y);
				}
			if (yval<ynewval) {
				Point pt1=water.cellPt(0,yval);
				view.repaint(pt1.x,pt1.y,pt2.x-pt1.x,pt2.y-pt1.y);
				}
			//viewpane.setSize(pt2.x,pt2.y);
			fview.pack();
		}

		synchronized public void addTimers(byte tp)
		{
			for (int y=0;y<sizey.val;y++) {
				Vector v=getfld(y);
				for (int x=0;x<sizex.val;x++) {
					Field f=(Field)v.elementAt(x);
					if (tp==img.MAX || tp==f.getValue())
						f.addTimer();
					}
				}
		}

		public void addAllTimers()
		{ addTimers(img.MAX); }

		synchronized boolean putFieldToField(byte tpd,byte tps)
		{
			Point pt;
			if ((pt=view.getAnyFld(tps))==null) return(true);
			Field f=getfld(pt),newf;
			setfld(pt,(newf=water.create(pt,tpd)));
			f.dispose(); newf.paint();
			return(false);
		}
	}

	private class ToolBox extends Panel implements MouseListener
	{
	byte tp;

		public ToolBox(byte _tp)
		{
			tp=_tp;
		}
		public void paint(Graphics g)
		{ img.draw(g,tp,new Point(0,0),(tp==tool?Color.black:null),this); }
		public void update(Graphics g)
		{ paint(g); }
		public void mouseClicked (MouseEvent e) {}
		public void mouseEntered (MouseEvent e) {}
		public void mouseReleased(MouseEvent e) {}
		public void mouseExited  (MouseEvent e) {}
		public void mousePressed (MouseEvent e)
		{
			if (tool==tp) return;
			tools[tool].repaint();
			tool=tp;
			repaint();
		}
		public Dimension getPreferredSize()
		{ return(new Dimension(img.sizex,img.sizey)); }
		public Dimension getMinimumSize()
		{ return(getPreferredSize()); }
	}

	private void shutdown()
	{
		fview.dispose(); fcontrol.dispose();
		if (doexit) System.exit(0);
		stop();
	}

	private class WindowClose implements WindowListener
	{
		public void windowOpened     (WindowEvent e) {}
		public void windowClosed     (WindowEvent e) {}
		public void windowIconified  (WindowEvent e) {}
		public void windowDeiconified(WindowEvent e) {}
		public void windowActivated  (WindowEvent e) {}
		public void windowDeactivated(WindowEvent e) {}
		public void windowClosing    (WindowEvent e)
		{ shutdown(); }
	}

	private class ButtonQuit implements ActionListener
	{
		public void actionPerformed(ActionEvent e)
		{ shutdown(); }
	}

	private class ButtonStartStop implements ActionListener
	{
	Button b;

		public ButtonStartStop(Button _b)
		{ b=_b; }

		public void actionPerformed(ActionEvent e)
		{
			running=!running;
			if (!running) {
				timerq.clear();
				b.setLabel("Start");
				return;
				}
			b.setLabel("Stop");
			timerq.runday();
			view.addAllTimers();
		}
	}

	private class EScrollbar extends Scrollbar
	{
		public EScrollbar(int i1,int i2,int i3,int i4,int i5)
		{ super(i1,i2,i3,i4,i5); }
		public Dimension getPreferredSize()
		{ return(new Dimension(100,super.getPreferredSize().height)); }
	}

	private class ScrollBarVal implements AdjustmentListener
	{
	public int val,newval;
	public Panel panel;

	Scrollbar bar;
	Label prelab,lab;
	protected int visible=2; //divisor!
	AdjustmentListener listener;
	String suffix="";

		private int getVis(int val)
		{ return(Math.max(1,val/visible)); }

		public ScrollBarVal(String lval,int _val,int min,int max,AdjustmentListener _listener)
		{
			val=0;
			listener=_listener;
			panel=new Panel();
			panel.add(prelab=new Label(lval+":"));
			panel.add(bar=new EScrollbar(EScrollbar.HORIZONTAL,0,getVis(max),min,max+getVis(max)));
			bar.setSize(300,bar.getSize().height);
			panel.add(lab=new Label(Integer.toString(val)));
			bar.addAdjustmentListener(this);
			setValue(_val);
		}

		synchronized public void adjustmentValueChanged(AdjustmentEvent e)
		{
			newval=bar.getValue();
			lab.setText(Integer.toString(newval)+suffix);
			if (newval==val) return;
			if (listener!=null)
				listener.adjustmentValueChanged(e);
			val=newval;
		}

		public void setValue(int _val)
		{ bar.setValue(_val); adjustmentValueChanged(null); }
		public void dec()
		{ if (val>0) setValue(val-1); }
		public void inc()
		{ if (val<bar.getMaximum()+visible) setValue(val+1); }
		public void setMax(int _val)
		{ bar.setVisibleAmount(getVis(_val)); bar.setMaximum(_val+bar.getVisibleAmount()); adjustmentValueChanged(null); }
		public int getMax()
		{ return(bar.getMaximum()-bar.getVisibleAmount()); }

		public void setSuffix(String s)
		{ suffix=s; adjustmentValueChanged(null); }
	}

	private abstract class Controller implements AdjustmentListener
	{
	protected ScrollBarVal cnt;
	byte tp;
	boolean silent=false;

		public void setup(byte _tp,String s)
		{
			tp=_tp;
			cnt=new ScrollBarVal(s,0,0,200,this);
			}
		public void setCount(int _cnt)
		{ if (!silent) cnt.setValue(_cnt); }

		public void adjustmentValueChanged(AdjustmentEvent e)
		{ //cnt
		Point pt;
			if (cnt==null) return;
			if (cnt.newval==fldcnt[tp]) return;
			silent=true;
			while (cnt.newval<fldcnt[tp])
				if (view.putFieldToField(img.LAND,tp)) break;
			while (cnt.newval>fldcnt[tp])
				if (view.putFieldToField(tp,img.LAND)) break;
			silent=false;
			setCount(fldcnt[tp]);
		}
	}

	private class Side extends Controller implements AdjustmentListener
	{
	ScrollBarVal speed;
	boolean wh;
	public Panel control;

		public String toString() { return(wh?"Y":"X"); }
		public Side(boolean _wh,int _speed)
		{
			setup((_wh?img.ROBOTY:img.ROBOTX),"Count");
			wh=_wh;
			control=new Panel();
			control.setBackground(Color.gray);
			control.setLayout(new GridLayout(0,1));
			control.add(new Label(toString()+" control:"));
			control.add(cnt.panel);
			control.add((speed=new ScrollBarVal("Speed",_speed,1,100,null)).panel);
			}
	}

	private class FoodCnt extends Controller implements AdjustmentListener
	{ public FoodCnt() { setup(img.FOOD,"Food count"); } }

Side sidex,sidey;
ScrollBarVal sizex,sizey,lenx,leny,fightday,fightnight,daytime,foodwght;
boolean pertp;
ItemListener dayboxdog;
Checkbox daybox;
FoodCnt foodcnt;

	private class DayLengther implements AdjustmentListener,ItemListener
	{
	boolean b;

		public DayLengther(boolean _b)
		{ b=_b; }
		
		public void adjustmentValueChanged(AdjustmentEvent e)
		{
			if (b==pertp && daytime!=null)
				daytime.setMax((b?leny:lenx).newval-1);
		}

		public void itemStateChanged(ItemEvent e)
		{
			if (pertp==!daybox.getState()) return;
			pertp=!pertp;
			daytime.prelab.setText(pertp?"Night time:":"Day time:");
			daytime.setMax((pertp?leny:lenx).newval-1);
			daytime.setValue(0);
			if (!pertp) view.addTimers(img.ROBOTX);
		}
	}

	public void run()
	{
		img=new Imager(imageloader);
		Frame fr;
		fr=fview=new Frame("Islet Island View");
		fr.addWindowListener(new WindowClose());
		//viewpane=new ScrollPane(ScrollPane.SCROLLBARS_ALWAYS);
		//viewpane.add(view=new View());
		//fr.add(viewpane);
		fr.add(view=new View());
		view.addMouseListener(view);
		view.addMouseMotionListener(view);
		fr=fcontrol=new Frame("Islet Control Panel");
		fview.setLocation(300,10);
		fcontrol.setLocation(10,10);
		fcontrol.setSize(280,660);
		fr.addWindowListener(new WindowClose());
		fr.setLayout(new FlowLayout());
		{ Panel p=new Panel();
			p.setBackground(Color.gray);
			p.setLayout(new GridLayout(0,1));
			p.add((sizex=new ScrollBarVal("Isle width" ,0,0,100,view)).panel);
			p.add((sizey=new ScrollBarVal("Isle height",0,0,100,view)).panel);
			fr.add(p);
		}
		{ Panel p=new Panel();
			p.setBackground(Color.gray);
			p.add(new Label("Tools:"));
			for (byte i=0;i<tools.length;i++)
				p.add(tools[i]);
			fr.add(p);
		}
		{ Panel p=new Panel();
			p.setBackground(Color.gray);
			p.setLayout(new GridLayout(0,1));
			p.add((lenx=new ScrollBarVal("Day length"  ,20,1,200,new DayLengther(false))).panel);
			p.add((leny=new ScrollBarVal("Night length",20,1,200,new DayLengther(true ))).panel);
			{ Panel q=new Panel();
				q.add(daybox=new Checkbox("Day?",true));
				p.add(q);
			}
			daybox.addItemListener(dayboxdog=new DayLengther(false));
			p.add((daytime=new ScrollBarVal("Day time"  ,0,0,20,null)).panel);
			fr.add(p);
		}
		{ Panel p=new Panel();
			p.setBackground(Color.gray);
			p.setLayout(new GridLayout(0,1));
			p.add((fightday=new ScrollBarVal("X<day>Y",20,0,100,null)).panel);
			p.add((fightnight=new ScrollBarVal("X<night>Y",80,0,100,null)).panel);
			fr.add(p);
		}
		{ Panel p=new Panel();
			p.setBackground(Color.gray);
			p.setLayout(new GridLayout(0,1));
			p.add((foodwght=new ScrollBarVal("Food weight",50,0,200,null)).panel);
			foodwght.setSuffix("%");
			p.add((foodcnt=new FoodCnt()).cnt.panel);
			fr.add(p);
		}
		fr.add((sidex=new Side(false,15)).control);
		fr.add((sidey=new Side(true ,10)).control);
		{ Panel p=new Panel();
			p.setBackground(Color.gray);
			{ Button b=new Button("Start");
				b.addActionListener(new ButtonStartStop(b));
				p.add(b);
			}
			{ Button b=new Button("Quit");
				b.addActionListener(new ButtonQuit());
				p.add(b);
			}
			fr.add(p);
		}
		sizex.setValue(20);
		sizey.setValue(20);
		sizex.bar.setMinimum(1);
		sizey.bar.setMinimum(1);
		prepared=true; view.repaint();
		fview.show(); fcontrol.show();

		new IntBugCheck(this);
		boolean buggy=true;
		try { sleep(100); }
		catch (InterruptedException e) { buggy=false; }
		System.out.println(toString()+" - check for Netscape Communicator 4.05 Preview Release 1 (AWT 1.1.5) interrupt() bug: "
			+(buggy?"FOUND, workarounding it.":"none, OK"));

		for (;;) {
			try {
				long l=timerq.getMin();
				if (l>buggywait && buggy) l=buggywait;
				sleep(l);
				}
			catch (InterruptedException e) {}
			}
	}
}//IsletThread
}//Islet