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

public class balance extends Applet implements Runnable
{
	final int SHP_WIDTH=10;
	final double ANGLE_INCREMENT=.2;
	final double SCALES=2;
	final double ANGLE=9;
	final int SHP_HEIGHT=20;
	int LOW=1;
	int HIGH=6;
	int NUMBER=2;
	int INCREASE=4;
	boolean WON_LAST=false;
	boolean DEBUG_VALUES=false;
	Random randomizer=new Random();

	int[] weights=new int[] {2,3,5,1};

	public Button myCheck,myReset,myAns,myNew;

	boolean run_thread=false;
	boolean stop = false;

	int w=0;

	Shapes All=new Shapes();
	Shapes suu=new Shapes();
	Shape[] choicesArray=new Shape[4];
	Shapes choices=new Shapes();
	Shape[] ShapesUp=new Shape[0];
	int WhichShape=-1;

	Image buffer;
	Graphics g;

	Point MouseAt=new Point(-1,-1);
	Point MouseIn=new Point(0,0);
	Point MouseStart=new Point(-1,-1);

	Scale s;
	Shape sq=new Shape();
	Shape sq2=new Shape();
	Shape sq3;

	Shape[] col=new Shape[10];
	Shape[] uu=new Shape[5];

	Point a;
	Point b;

	Thread t;

	double ScaleRotation=0;

	public void paint(Graphics g) { UpdateScene(); }

	public boolean action(Event event,Object arg)
	{
		if (event.target == myReset)
		{
			stop = true;
			while (run_thread == true) {}
			stop = false;

			ScaleRotation = 0;
			s.Clear();
			All.Clear();
		}
		else if (event.target == myCheck)
		{
			while (run_thread == true) {}

			boolean win = s.Check();
			Messenger m = new Messenger("",0,320,26);
			Messenger i = new Messenger("",0,350,16);
			char x;
			x=65;
			if (win)
			{
				if (INCREASE > NUMBER)
					i.Message="Push new for next level";
				m.Message="You WIN!";
				WON_LAST=true;
			}
			else
				m.Message="Try Again";
			ClearScene();
			s.Show();
			choices.Show();
			m.Show(1);
			i.Show(1);
			UpdateScene();
			return true;
		}
		else if (event.target == myAns)
		{
			s.DispAns();
		}
		else if (event.target == myNew)
		{
			stop = true;
			while (run_thread == true) {}
			stop = false;

			ScaleRotation = 0;

			if (INCREASE > NUMBER && WON_LAST)
				WON_LAST=(++NUMBER)<0;

			s.NewProblem(RandomWeights(NUMBER,LOW,HIGH),RandomStarts(NUMBER,1));
			All.Clear();
		}
		ClearScene();
		s.Show();
		choices.Show();
		UpdateScene();
		run_thread=true;
		return true;
	}

	public void init()
	{

		int t1=0,t2=0;
		String s1,s2;
		s1 = getParameter("RANGE LOW");
		s2 = getParameter("RANGE HIGH");
		if (s1 != null)
			t1 = MakeNum(s1);
		if (s2 != null)
			t2 = MakeNum(s2);

		if (!(t1 < 1 || t2 < 1 || t1 > 10 || t2 > 10 || t1 > t2))
		{
			LOW = t1;
			HIGH = t2;
		}
		else
		{
			LOW = 1;
			HIGH = 6;
		}

		t1 = 0;
		s1 = getParameter("SHAPES");
		if (s1 != null)
			t1 = MakeNum(s1);
		if (!(t1 < 2 || t1 > 4))
			NUMBER = t1;
		else
			NUMBER = 2;

		t1 = 0;
		s1 = getParameter("OPTIONAL INCREASE TO");
		if (s1 != null)
			t1 = MakeNum(s1);
		if (!(t1 < 2 || t1 > 4))
			INCREASE = t1;
		else
			INCREASE = 4;

		String temp;
		temp=getParameter("OPTIONAL DEBUG");
		if (temp != null && temp.equals("TRUE"))
			DEBUG_VALUES = true;
		else
			DEBUG_VALUES = false;

		setLayout(null);

		sq=new Shape(new Point(100,100),new int[] {0,0,10,10},new int[] {0,-10,-10,0},false,Color.black,true,true,Color.orange,"", Color.black,new Point(10,-5),true,0,SCALES,15,5,1);
		sq2=new Shape(new Point(100,100),new int[] {0,5,10},new int[] {0,-10,0}, false,Color.black,true,true,Color.cyan,"",Color.black,new Point(10,-5),true,0,SCALES,15,6,2);

		All.setFocus(0);

		buffer=createImage(size().width,size().height);
		g=buffer.getGraphics();

		choicesArray[0]=new Shape(new Point(20,300),new int[] {1,1,9,9},new int[] {-1,-9,-9,-1},false,Color.black,true,true,Color.green,"",Color.black,new Point(5,-20),true,0,SCALES,10,weights[0],1);

		choicesArray[1]=new Shape(new Point(20,350),numList(new int[] {4},5,1,5),numList(new int[] {-4},5,2,-4),false,Color.black,true,true,Color.magenta,"",Color.black,new Point(5,-20),true,0,SCALES,10,weights[1],2);

		choicesArray[2]=new Shape(new Point(20,400),new int[] {1,5,9},new int[] {-1,-9,-1},false,Color.black,true,true,Color.pink,"",Color.black,new Point(5,-20),true,0,SCALES,10,weights[2],3);

		choicesArray[3]=new Shape(new Point(20,400),numList(new int[] {2,4},8,1,5),numList(new int[] {2,4},8,2,-4),false,Color.black,true,true,new Color(253,159,66),"",Color.black,new Point(5,-20),true,0,SCALES,10,weights[3],4);

		choices.Add(choicesArray);

		s=new Scale();

		s.Init(200,200,SCALES,choicesArray,new boolean[] {false,true,false,false},this,NUMBER);

		s.NewProblem(RandomWeights(NUMBER,LOW,HIGH),RandomStarts(NUMBER,1));

		s.setTilt(ScaleRotation);

		ClearScene();
		choices.Show();
		s.Show();
		UpdateScene();
	}

//Graphing helper functions
	public void ClearScene()
	{
		g.setColor(Color.white);
		g.fillRect(0,0,size().width,size().height);
	}

	public void UpdateScene()
	{

		Graphics b=this.getGraphics();
		b.drawImage(buffer,0,0,this);
	}

//Thread functions
	public void start()
	{

		if(t == null)
		{
			t = new Thread(this);
			t.start();
		}
	}

	public void stop()
	{
		t = null;
	}

	public void run()
	{
		int sign1, sign2;
		Thread current = Thread.currentThread();

		while(t == current)
		{
			if (run_thread)
			{
				sign1=Sign(s.getTilt());
				sign2=Sign(ScaleRotation);
				while (!stop && !Equals(ScaleRotation,s.getTilt()))
				{
					try
					{
						Thread.sleep(10);
					}
					catch(InterruptedException e) {}
					if (!stop)
					{
						if (ScaleRotation == 0)
							s.setTilt(s.getTilt()-ANGLE_INCREMENT*sign1);
						else
							s.setTilt(s.getTilt()+ANGLE_INCREMENT*sign2);
						ClearScene();
						s.ShowScale();
						choices.Show();
						All.Show();
						s.ShowShapes();
						UpdateScene();
					}
				}
				run_thread=false;
				stop = false;
			}
		}

		ClearScene();
		s.Show();
		choices.Show();
		UpdateScene();
	}

	public boolean mouseDown(Event e,int x,int y)
	{
		choices.ChooseClosest(new Point(x,y));
		All.ChooseClosest(new Point(x,y));
		if (choices.getFocus()!=-1)
			if (choices.Inside(new Point(x,y)))
			{
				All.Add(new Shape(choices.ShapeByIndex()));
				MouseAt=new Point(x,y);
				MouseIn=new Point(All.getPos().X()-x,All.getPos().Y()-y);
				MouseStart=new Point(x,y);
				return true;
			}
		if (All.getFocus()!=-1)
			if (All.Inside(new Point(x,y)))
			{
				MouseAt=new Point(x,y);
				MouseIn=new Point(All.getPos().X()-x,All.getPos().Y()-y);
				MouseStart=new Point(x,y);
				return true;
			}
		MouseAt=new Point(-1,-1);
		return true;
	}

	public boolean mouseUp(Event e,int x,int y)
	{
		if (!Equals(MouseAt,new Point(-1,-1)))
		{
			stop = true;
			while (run_thread == true) {}
			stop = false;

			ClearScene();
			Pair p;
			p=s.ShapeMotion(MouseStart,MouseAt,All.ShapeByIndex());

			if (p.second>-1)
			{
				if (p.second<2)
				{
					All.Remove(All.getFocus());
				}
				ScaleRotation = p.first;
			}
			s.Show();
			choices.Show();
			UpdateScene();
			run_thread=true;
		}
		MouseAt=new Point(-1,-1);
		return true;
	}

	public boolean mouseDrag(Event e,int x,int y)
	{
		if (!Equals(MouseAt,new Point(-1,-1)))
		{
			All.setPos(new Point(MouseIn.X()+x,MouseIn.Y()+y));
			MouseAt=new Point(x,y);
			if (!run_thread)
			{
				ClearScene();
				s.ShowScale();
				choices.Show();
				All.Show();
				s.ShowShapes();
				UpdateScene();
			}
		}
		return true;
	}

	public int[] RandomWeights(int n,int lower_limit, int upper_limit)
	{
		int[] dummy = new int[n];
		if (DEBUG_VALUES)
Debug("The weights are:");
		for(int i=0;i<n;i++)
		{
			dummy[i] = ((int)(randomizer.nextDouble() * (upper_limit - lower_limit) + lower_limit));
			if (DEBUG_VALUES)
				Debug("Weight " + (i+1) + "=" + dummy[i]);
		}
		if (DEBUG_VALUES)
Debug("");
		return dummy;
	}

	public boolean[] RandomStarts(int total, int shown)
	{
		int counter=shown;
		boolean[] dummy=new boolean[total];
		for(int i=0;i<total;i++)
			dummy[i]=false;
		for(int i=0;counter>0;i=(i+1) % total)
			if (dummy[i] == false)
				if (randomizer.nextDouble() < ((double)shown/(double)total))
					dummy[i] = (--counter > -1);
		return dummy;
	}

	public int MakeNum(String s)
	{
		if (s.length() == 0)
			return 0;
		int dummy=0;
		char temp;
		int c=1;
		for(int i=s.length()-1;i>-1;i--)
		{
			temp = s.charAt(i);
			if (temp >= '0' && temp <= '9')
			{
				dummy = dummy + c*(temp-'0');
				c = c*10;
			}
		}
		if (s.charAt(0) == '-')
			dummy=dummy*-1;
		return dummy;
	}

	public Pair MakePair(double x,double y) { return new Pair(x,y); }

	public int[] numList(int[] factors,int segments,int func,int off)
	{
		int[] temp=new int[segments];
		for(int c=0;c<segments;c++)
			switch (func)
			{
				case 1:
					temp[c]=((int)Math.round(Math.sin(Math.PI*2/segments*c)*factors[c % factors.length]))+off;
					break;
				case 2:
					temp[c]=((int)Math.round(Math.cos(Math.PI*2/segments*c)*factors[c % factors.length]))+off;
					break;
			}
		return temp;
	}

	public int Sign(double n)
	{
		if (n>0)
			return 1;
		if (n<0)
			return -1;
		return 0;
	}

	public boolean Equals(Point a,Point b) { return (Equals(a.X(),b.X()) & Equals(a.Y(),b.Y())); }

	public boolean Equals(double a,double b) { return (Math.abs(a-b)<.001); }

	public int[] Add(int i,int[] a)
	{
		int[] dummy;
		if (a.length==0)
		{
			dummy=new int[1];
			dummy[0]=i;
		}
		else
		{
			dummy=new int[a.length+1];
			for(int c=0;c<a.length;c++)
				dummy[c]=a[c];
			dummy[a.length]=i;
			a=dummy;
		}
		return dummy;
	}

	public int[] Remove(int i,int[] a)
	{
		int[] dummy=new int[a.length-1];
		for(int c=0;c<a.length;c++)
			if (c > i)
				dummy[c-1]=a[c];
			else if (c < i)
				dummy[c]=a[c];
		return dummy;
	}

	public int Find(int i,int[] a)
	{
		for(int c=0;c<a.length;c++)
			if (a[c]==i)
				return c;
		return -1;
	}

	public int[] RemoveEntry(int i,int[] a)
	{
		int dummy=Find(i,a);
		if (dummy != -1)
			return Remove(dummy,a);
		return a;
	}

	public int value(String s)
	{
		int dummy=0;
		int level=1;
		for(int c=s.length()-1;c>-1;c--)
		{
			dummy += (s.charAt(c)-'0')*level;
			level *= 10;
		}
		return dummy;
	}


//Scale Class
	class Scale
	{
		public void NewProblem(int[] w,boolean[] sw)
		{
			for(int i=0;i<myText.length;i++)
			{
				if (i < w.length)
				{
					myChoices.setVisible(i,true);
					myChoices.setEnabled(i,true);
					myText[i].setVisible(true);
					myChoices.setWeight(i,w[i]);
					myShowWhich[i] = sw[i];
				}
				else
				{
					myChoices.setVisible(i,false);
					myChoices.setEnabled(i,false);
					myText[i].setVisible(false);
				}
			}
			myHowMany = w.length;
			Reset();
		}

		public void DispAns()
		{
			for(int i=0;i<myHowMany;i++)
				myText[i].setText("" + myChoices.getWeight(i));
		}

		public void Reset()
		{
			Clear();
			for(int i=0;i<myHowMany;i++)
				if (myShowWhich[i])
					myText[i].setText("" + myChoices.getWeight(i));
				else
					myText[i].setText("");
		}

		public void Clear()
		{
			In1.Clear();
			In2.Clear();
			W1=0;
			W2=0;
		}

		public Pair ShapeMotion(Point s, Point f, Shape i)
		{
			double dummy=beam.getRotation();
			double removed=0;
			boolean s1,s2,f1,f2;
			s1 = catch1.Inside(s);
			s2 = catch2.Inside(s);
			f1 = catch1.Inside(f);
			f2 = catch2.Inside(f);
			if ((s1 && f1) || (s2 && f2))
			{
				AllignShapes(In1,pan1);
				AllignShapes(In2,pan2);
				return MakePair(0.0,-10.0);
			}
			if (s1 || s2)
			{
				dummy = RemoveShape(i);
				removed=removed+1;
			}
			if (f1)
			{
				dummy=AddShape(1,i);
				removed=removed+2;
			}
			if (f2)
			{
				dummy=AddShape(2,i);
				removed=removed+2;
			}
			AllignShapes(In1,pan1);
			AllignShapes(In2,pan2);
			return MakePair(dummy,removed);
		}

		public void Scale()
		{
			myScaling = 1;
		}

		public double getTilt()
		{
			return beam.getRotation();
		}

		public void setTilt(double t)
		{
			beam.setRotation(t);
			beam.Update();
			pan1.Move(beam.PointOnPoly(1));
			pan2.Move(beam.PointOnPoly(2));
			pan1.Update();
			pan2.Update();
			catch1.Move(pan1.PointOnPoly(2));
			catch2.Move(pan2.PointOnPoly(2));
			MyScale.UpdateAll();
			AllignShapes(In1,pan1);
			AllignShapes(In2,pan2);
		}

		public void Init(int x, int y, double sc, Shape[] s, boolean[] sw, balance o, int how_many)
		{
			myChoices=new Shapes();
			myScaling = sc;
			myChoices.Add(s);
			Init(x,y);
			myText=new TextField[sw.length];
			setLayout(null);
			myShowWhich = new boolean[sw.length];
			for(int i=0;i<s.length;i++)
			{
				myChoices.setPos(i,x-(int)(sc*13),y+(int)(sc*42)+(int)(i*12*sc));
				if (sw[i])
					myText[i]=new TextField(""+myChoices.getWeight(i),30);
				else
					myText[i]=new TextField("",30);
				myText[i].setBounds(x+(int)(sc*5),y+(int)(sc*34)+(int)(i*12*sc),30,20);
				o.add(myText[i]);
				myShowWhich[i] = sw[i];
				if (i >= how_many)
				{
					myChoices.setVisible(i,false);
					myChoices.setEnabled(i,false);
					myText[i].setVisible(false);
				}
				myHowMany = how_many;
			}

			myCheck=new Button("Check");
			myCheck.setForeground(Color.black);
			myCheck.setBackground(Color.lightGray);
			myCheck.setBounds(x+(int)(sc*20),y+(int)(sc*34),60,20);

			myAns =new Button("Answer");
			myAns.setForeground(Color.black);
			myAns.setBackground(Color.lightGray);
			myAns.setBounds(x+(int)(sc*50),y+(int)(sc*34),60,20);

			myReset =new Button("Clear");
			myReset.setForeground(Color.black);
			myReset.setBackground(Color.lightGray);
			myReset.setBounds(x+(int)(sc*20),y+(int)(sc*44),60,20);

			myNew =new Button("New");
			myNew.setForeground(Color.black);
			myNew.setBackground(Color.lightGray);
			myNew.setBounds(x+(int)(sc*50),y+(int)(sc*44),60,20);

			o.add(myCheck);
			o.add(myAns);
			o.add(myReset);
			o.add(myNew);
		}

		public boolean Check()
		{
			String temp1,temp2;
			int c=0;
			for(int i=0;i<myHowMany;i++)
				if (MakeNum(myText[i].getText()) != myChoices.getWeight(i))
					return false;
			return true;
		}

		public void Init(int x, int y, double sc)
		{
			myScaling = sc;
			Init(x,y);
		}

		public void Init(int x, int y)
		{

			support = new Shape(new Point(x,y), new int[] {0,20,-20}, new int[] {0,30,30}, false, Color.black, false, true,Color.blue,"",Color.black,new Point(0,0),true,0,1,12,0,0);

			beam = new Shape(new Point(x,y), new int[] {-50,-50,50,50}, new int[] {0,-10,-10,0}, false, Color.black, false, true,Color.red,"",Color.black,new Point(0,0),true,0,1,12,0,0);

			pan_height=10;

			pan1 = new Shape(new Point(x+50,y-10),new int[] {0,20,-20},new int[] {0,-10,-10},false,Color.black, false,true,Color.red,"",Color.black,new Point(0,0),true,0,1,12,0,0);

			pan2 = new Shape(new Point(x-50,y-10),new int[] {0,20,-20},new int[] {0,-10,-10} ,false,Color.black, false,true,Color.red,"",Color.black,new Point(0,0),true,0,1,12,0,0);

			catch1 = new Shape(new Point(x-60,y-30),new int[] {0,20,40,40,0},new int[] {0,10,0,-50,-50},false,Color.lightGray, false,false,Color.blue,"",Color.lightGray,new Point(0,0),true,0,1,12,0,0);

			catch2 = new Shape(new Point(x-40,y-30),new int[] {0,20,40,40,0},new int[] {0,10,0,-50,-50},false,Color.lightGray, false,false,Color.blue,"",Color.lightGray,new Point(0,0),true,0,1,12,0,0);

			support.setScale(myScaling);
			beam.setScale(myScaling);
			pan1.setScale(myScaling);
			pan2.setScale(myScaling);
			catch1.setScale(myScaling);
			catch2.setScale(myScaling);

			MyScale=new Shapes();
			MyScale.Add(new Shape[] {support,beam,catch1,catch2,pan1,pan2});

			MyScale.UpdateAll();

			In1=new Shapes();
			In2=new Shapes();

			Loc = new Point(x,y);

			setTilt(0);
		}

		public void ShowScale()
		{
			MyScale.Show();
		}

		public void ShowShapes()
		{
			In1.Show(-1);
			In2.Show(-1);
		}

		public void Show()
		{
			MyScale.Show();
			In1.Show(-1);
			In2.Show(-1);
		}

		public double AddShape(int Side, Shape s)
		{
			if (Side==1)
			{
				s.setScale(myScaling);
				In1.Add(s);
				W1=W1+s.getWeight();
			}
			else
			{
				s.setScale(myScaling);
				In2.Add(s);
				W2=W2+s.getWeight();
			}

			if (W1>W2)
				return -ANGLE;
			else if (W2>W1)
				return ANGLE;
			else
				return 0;
		}

		public double RemoveShape(Shape s)
		{
			if (In1.Find(s)!=-1)
			{
				In1.RemoveEntry(s);
				W1=W1-s.getWeight();
				AllignShapes(In1,pan1);
			}
			else if (In2.Find(s)!=-1)
			{
				In2.RemoveEntry(s);
				W2=W2-s.getWeight();
				AllignShapes(In2,pan2);
			}

			if (W1>W2)
				return -ANGLE;
			else if (W2>W1)
				return ANGLE;
			else
				return 0;
		}

		private void AllignShapes(Shapes i, Shape pan)
		{
			int[] typs=new int[0];
			int typ;
			int dummy;
			double panx;
			double pany;
			panx=pan.PointOnPoly(2).X();
			pany=pan.PointOnPoly(2).Y();

			if (i.size() < 21)
				for (int c=0;c<i.size();c++)
				{
					i.setPos(c,(int)(panx+SHP_WIDTH*(c%4)*myScaling),(int)(pany-SHP_HEIGHT*Math.floor(c/4)));
					i.setText(c,"");
				}
			else
				for (int c=0;c<i.size();c++)
				{
					typ=i.getType(c);
					dummy=Find(typ,typs);
					if (dummy==-1)
					{
						typs=Add(typ,typs);
						i.setPos(c,(int)(panx+SHP_WIDTH*(typs.length-1)*myScaling),(int)pany);
						CompactType(typ,i);
					}
				}
		}

		private Shapes CompactType(int typ,Shapes i)
		{
			if (i.size() == 0)
				return i;
			int temp=-1;
			int counter=0;
			for(int c=0;c<i.size();c++)
			{
				if (i.getType(c)==typ)
				{
					counter++;
					if (temp==-1)
						temp=c;
					else
					{
						i.setText(c,"");
						i.setPos(c,i.getPos(temp));
						i.MoveBy(c,0,0);
					}
				}
			}
			if (temp != -1)
				i.setText(temp,String.valueOf(counter));
			return i;
		}

		private int myHowMany;
		private boolean[] myShowWhich;
		private double myScaling;
		private Shapes myChoices;
		private Shape myButtonBorder;
		private TextField[] myText;
		private int[] myShowWeights;
		private Point Loc;
		private int W1;
		private int W2;
		private int pan_height;
		private Shapes MyScale;
		private Shape beam;
		private Shape support;
		private Shape pan1;
		private Shape pan2;
		private Shape catch1;
		private Shape catch2;
		private Shapes In1;
		private Shapes In2;
	}



//Shapes Class
	class Shapes
	{

		public void Clear()
		{
			NOS=0;
			MyShapes=new Shape[0];
		}

		public int ShapeIndex(Shape i)
		{
			for (int c=0;c<NOS;c++)
				if (MyShapes[c] == i)
					return c;
			return -1;
		}

		public Shape ShapeByIndex(int i) { return MyShapes[i]; }
		public Shape ShapeByIndex() { return MyShapes[focus]; }

		public void Shapes()
		{
			focus=0;
			NOS=0;
			MyShapes=new Shape[1];
		}

		public void Show()
		{
			for (int i=0;i<NOS;i++)
				MyShapes[i].Show();
		}

		public void Show(int k)
		{
			if (k==1)
				Show();
			else if (k==-1)
				for (int i=NOS-1;i>-1;i--)
					MyShapes[i].Show();
		}

		public void Add(Shape s)
		{
			Shape[] dummy=new Shape[NOS+1];
			for(int i=0;i<NOS;i++)
				dummy[i]=MyShapes[i];
			dummy[NOS]=s;
			MyShapes=dummy;
			focus=NOS;
			NOS++;
		}

		public void Add(Shape[] s)
		{
			Shape[] dummy=new Shape[NOS+s.length];
			for(int i=0;i<NOS;i++)
				dummy[i]=MyShapes[i];
			for(int i=NOS;i<NOS + s.length;i++)
				dummy[i]=s[i-NOS];
			MyShapes=dummy;
			focus=NOS;
			NOS=NOS + s.length;
		}

		public void Remove(int s)
		{
			Shape[] dummy=new Shape[NOS-1];
			for(int c=0;c<NOS;c++)
				if (c > s)
					dummy[c-1]=MyShapes[c];
				else if (c < s)
					dummy[c]=MyShapes[c];
			MyShapes=dummy;
			NOS--;
		}

		public int Find(Shape s)
		{
			for(int c=0;c<NOS;c++)
				if (MyShapes[c]==s)
					return c;
			return -1;
		}

		public void RemoveEntry(Shape s)
		{
			int dummy=Find(s);
			if (dummy!=-1)
				Remove(dummy);
		}

		public int size() { return NOS; }

		public void UpdateAll()
		{
			for (int c=0;c<NOS;c++)
				MyShapes[c].Update();
		}

		public void MoveBy(int x, int y) { MyShapes[focus].MoveBy(x,y); }
		public void MoveBy(int i, int x, int y) { MyShapes[i].MoveBy(x,y); }

		public void Update() { MyShapes[focus].Update(); }
		public void Update(int i) { MyShapes[i].Update(); }

		public Point getPointOnPoly(int p) { return MyShapes[focus].PointOnPoly(p); }
		public Point getPointOnPoly(int i, int p) { return MyShapes[i].PointOnPoly(p); }

		public double getRotation() { return MyShapes[focus].getRotation(); }
		public void setRotation(double r) { MyShapes[focus].setRotation(r); }
		public double getRotation(int i) { return MyShapes[i].getRotation(); }
		public void setRotation(int i, double r) { MyShapes[i].setRotation(r); }

		public String getText(int i) { return MyShapes[i].getText(); }
		public void setText(int i, String t) { MyShapes[i].setText(t); }
		public String getText() { return MyShapes[focus].getText(); }
		public void setText(String t) { MyShapes[focus].setText(t); }

		public int getType(int i) { return MyShapes[i].getType(); }
		public void setType(int i, int t) { MyShapes[i].setType(t); }
		public int getType() { return MyShapes[focus].getType(); }
		public void setType(int t) { MyShapes[focus].setType(t); }

		public int getWeight(int i) { return MyShapes[i].getWeight(); }
		public void setWeight(int i, int w) { MyShapes[i].setWeight(w); }
		public int getWeight() { return MyShapes[focus].getWeight(); }
		public void setWeight(int w) { MyShapes[focus].setWeight(w); }

		public Color getColor(int i) { return MyShapes[i].getColor(); }
		public void setColor(int i, Color c) { MyShapes[i].setColor(c); }
		public Color getColor() { return MyShapes[focus].getColor(); }
		public void setColor(Color c) { MyShapes[focus].setColor(c); }

		public Color getFillColor(int i) { return MyShapes[i].getFillColor(); }
		public void setFillColor(int i,Color c) { MyShapes[i].setFillColor(c); }
		public Color getFillColor() { return MyShapes[focus].getFillColor(); }
		public void setFillColor(Color c) { MyShapes[focus].setFillColor(c); }

		public boolean getEnabled() { return MyShapes[focus].getEnabled(); }
		public void setEnabled(boolean e) { MyShapes[focus].setEnabled(e); }

		public boolean getEnabled(int i) { return MyShapes[i].getEnabled(); }
		public void setEnabled(int i,boolean e) { MyShapes[i].setEnabled(e); }

		public void setFocus(int f) { focus=f; }
		public int getFocus() { return focus; }

		public Point getPos() { return MyShapes[focus].Position(); }
		public Point getPos(int i) { return MyShapes[i].Position(); }

		public void setPos(Point p) { MyShapes[focus].Move(p); }
		public void setPos(int x,int y) { MyShapes[focus].Move(x,y); }
		public void setPos(int i,Point p) { MyShapes[i].Move(p); }
		public void setPos(int i,int x,int y) { MyShapes[i].Move(x,y); }

		public boolean Inside(Point p) { return MyShapes[focus].Inside(p); }
		public boolean Inside(int i,Point p) { return MyShapes[i].Inside(p); }
		public boolean Inside(int a,int b) { return (MyShapes[a].Inside(MyShapes[b].Position()) | MyShapes[b].Inside(MyShapes[a].Position())) & (MyShapes[a].getVisible() & MyShapes[b].getVisible()); }

		public void ChooseClosest(Point p) { focus=Closest(p,true); }
		public void ChooseClosestBackwards(Point p) { focus=ClosestBackwards(p,true); }

		public boolean getVisible(int i) { return MyShapes[i].getVisible(); }
		public void setVisible(int i, boolean v) { MyShapes[i].setVisible(v); }
		public boolean getVisible() { return MyShapes[focus].getVisible(); }
		public void setVisible(boolean v) { MyShapes[focus].setVisible(v); }

		public double getScale() { return MyShapes[focus].getScale(); }

		public void setScale(double r) { MyShapes[focus].setScale(r); }
		public double getSclae(int i) { return MyShapes[i].getScale(); }
		public void setScale(int i,double r) { MyShapes[i].setScale(r); }

		private int Closest(Point p,boolean IsInside)
		{
			double temp,a=1000000;
			int w=-1;
			for(int i=0;i<NOS;i++)
				if(((IsInside & MyShapes[i].Inside(p)) | !IsInside) & MyShapes[i].getEnabled())
					if (a > DistToCent(p,i))
						w=i;
			return w;
		}

		private int ClosestBackwards(Point p,boolean IsInside)
		{
			double temp,a=1000000;
			int w=-1;
			for(int i=NOS-1;i>-1;i--)
				if(((IsInside & MyShapes[i].Inside(p)) | !IsInside) & MyShapes[i].getEnabled())
					if (a > DistToCent(p,i))
						w=i;
			return w;
		}

		private double DistToCent(Point p,int i) { return Math.sqrt(Math.pow(p.X()-MyShapes[i].Position().X(),2) + Math.pow(p.Y()-MyShapes[i].Position().Y(),2)); }

		private Shape[] MyShapes;
		private int focus;
		private int NOS;
	}



//Shape class
	class Shape
	{
		public Shape(Point p, int[] px,int[] py, boolean r,Color c,boolean enabled,boolean fill,Color FillC,String txt,Color TxtCol,Point TextPt,boolean Vis,int ru,double sc,int fs, int wei,int typ)
		{
			Type=typ;
			Weight=wei;

			FontSize=fs;

			Scale=sc;

			Visible=Vis;

			TextPos=TextPt;

			Filled=fill;
			FillColor=FillC;

			Text=txt;
			TextColor=TxtCol;

			Enabled=enabled;

			int a,b;

			Pos=p;

			a=px.length;
			b=py.length;

			if (a>b)
				NOP=b;
			else
				NOP=a;

			int[][] temp={px,py};
			Poly=temp;

			PolyRotated=new int[2][NOP];

			System.arraycopy(px,0,PolyRotated[0],0,NOP);
			System.arraycopy(py,0,PolyRotated[1],0,NOP);

			if (r)
				Rotation=((int)(Math.random()*8))*45;
			else
				Rotation=0;

			Col=c;
		}

		public Shape(Shape s)
		{
			Type=s.Type;
			Weight=s.Weight;

			FontSize=s.FontSize;

			Scale=s.Scale;

			Visible=s.Visible;

			TextPos=s.TextPos;

			Filled=s.Filled;
			FillColor=s.FillColor;

			Text=s.Text;
			TextColor=s.TextColor;

			Enabled=s.Enabled;

			int a,b;

			Pos=new Point(s.Pos);

			a=s.Poly[0].length;
			b=s.Poly[1].length;

			if (a>b)
				NOP=b;
			else
				NOP=a;

			int[][] temp=new int[2][NOP];
			System.arraycopy(s.Poly[0],0,temp[0],0,NOP);
			System.arraycopy(s.Poly[1],0,temp[1],0,NOP);

			Poly=temp;

			PolyRotated=new int[2][NOP];

			System.arraycopy(s.PolyRotated[0],0,PolyRotated[0],0,NOP);
			System.arraycopy(s.PolyRotated[1],0,PolyRotated[1],0,NOP);

			Rotation=s.Rotation;

			Col=s.Col;
		}

		public Point PointOnPoly(int i)
		{
			if (i>-1 && i<NOP)
				return new Point(PolyRotated[0][i],PolyRotated[1][i]);
			return new Point(-1,-1);
		}

		public Point Position() { return Pos; }

		public void Update() { RT(); };

		public void Shape() { }

		public void Move(Point p) { Pos=p; }

		public void Move(int x,int y) { Pos=new Point(x,y); }

		public void MoveBy(int x,int y) { Pos=new Point(Pos.X()+x,Pos.Y()+y); }

		public void Show()
		{
			if (Visible)
			{
				RT();

				if (Filled)
				{
					g.setColor(FillColor);
					g.fillPolygon(PolyRotated[0],PolyRotated[1],NOP);
				}

				g.setColor(Col);
				g.drawPolygon(PolyRotated[0],PolyRotated[1],NOP);

				Font temp=g.getFont();
				g.setFont(temp.deriveFont((float)FontSize));
				g.setColor(TextColor);
				g.drawString(Text,Pos.X()+TextPos.X(),Pos.Y()+TextPos.Y());
				g.setFont(temp);
			}
		}

		public boolean Inside(Point p)
		{
			return (new Polygon(PolyRotated[0],PolyRotated[1],NOP).contains(p.X(),p.Y()));
		}

		public String getText() { return Text; }
		public void setText(String t) { Text=t; }

		public int getType() { return Type; }
		public void setType(int t) { Type=t; }

		public int getWeight() { return Weight; }
		public void setWeight(int w) { Weight=w; }

		public Color getColor() { return Col; }
		public void setColor(Color c) { Col=c; }

		public Color getFillColor() { return FillColor; }
		public void setFillColor(Color c) { FillColor=c; }

		public boolean getEnabled() { return Enabled; }
		public void setEnabled(boolean e) { Enabled=e; }

		public boolean getVisible() { return Visible; }
		public void setVisible(boolean v) { Visible=v; }

		public double getScale() { return Scale; }
		public void setScale(double s) { Scale=s; }

		public double getRotation() { return Rotation; }
		public void setRotation(double r) { Rotation=r; }

		private void RT()
		{
			int[] xp=new int[NOP];
			int[] yp=new int[NOP];
			double x,y,nx,ny;

			double rad=Rotation/180*Math.PI;

			System.arraycopy(Poly[0],0,xp,0,NOP);
			System.arraycopy(Poly[1],0,yp,0,NOP);

			for(int i=0;i<NOP;i++)
			{
				x=xp[i]*Scale;
				y=yp[i]*Scale;
				nx=x*Math.cos(rad)-y*Math.sin(rad)+Pos.X();
				ny=y*Math.cos(rad)+x*Math.sin(rad)+Pos.Y();
				xp[i]=(int)nx;
				yp[i]=(int)ny;
			}

			System.arraycopy(xp,0,PolyRotated[0],0,NOP);

			System.arraycopy(yp,0,PolyRotated[1],0,NOP);
		}

		public Shape() {}


		private int Type;
		private int FontSize;
		private int Weight;
		private Point Pos;
		private Point TextPos;
		private int[][] Poly;
		private int[][] PolyRotated;
		private int NOP;
		private double Scale;
		private String Text;
		private double Rotation;
		private Color FillColor;
		private Color Col;
		private Color TextColor;
		private boolean Enabled;

		private boolean Filled;
		private boolean Visible;
	}


//Pair Class
	class Pair
	{
		public Pair(double x,double y)
		{
			first=x;
			second=y;
		}
		public double first;
		public double second;
	}


//Point Class
	class Point
	{
		public Point(int x,int y)
		{
			myX=x;
			myY=y;
		}

		public Point(Point p)
		{
			myX=p.myX;
			myY=p.myY;
		}

		public int X() {return myX;}

		public int Y() {return myY;}

		private int myX;
		private int myY;
	}

	class Messenger
	{
		public Messenger(String s,int x,int y,int fs)
		{
			xPos=x;
			yPos=y;
			Message=s;
			myShape=new Shape(new Point(xPos,yPos),new int[] {},new int[] {},false,Color.gray,true,false,Color.black,Message,Color.red,new Point(0,0),true,0,1,fs,0,0);
		}

		public void Show(double sc)
		{
			myShape.Move(xPos,yPos);
			myShape.setText(Message);
			myShape.setScale(sc);
			myShape.Show();
		}

		private Shape myShape;
		public int xPos,yPos;
		public String Message;
	}

//Debugging Function
public void Debug(String s)
{
	System.out.println(s);
}
public void Debug(int s)
{
	System.out.println("" + s);
}
public void Debug(double s)
{
	System.out.println("" + s);
}
public void Debug()
{
	System.out.println("");
}

}