// Daniel Abplanalp (March 1996)
// abplana@beoberland.ch

import java.awt.* ;
import java.awt.image.* ;
import java.lang.* ;
import java.util.* ;
import java.net.* ;
import java.applet.*;

class vector
{ public double X,Y,Z; // Orginal Koordinaten
  public double x,y,z; // Bewegte Koordinaten
  public vector(){x=y=z=0.;X=Y=Z=0;};

  public vector(double xin,double yin,double zin)
  { x=X=xin;
    y=Y=yin;
    z=Z=zin;
  };
  public vector(String in)
  { int Komma1=in.indexOf(',');
    int Komma2=in.indexOf(',',Komma1+1);
	x=X=Integer.parseInt(in.substring(0,Komma1));
	y=Y=Integer.parseInt(in.substring(Komma1+1,Komma2));
	z=Z=Integer.parseInt(in.substring(Komma2+1));
  };
  public vector(int xin,int yin,int zin)
  { double sum=Math.sqrt(xin*xin+yin*yin+zin*zin);
    x=(double) xin/sum;
    y=(double) yin/sum;
    z=(double) zin/sum;
  }
  public void def(double xin,double yin,double zin)
  { x=X=xin;
    y=Y=yin;
    z=Z=zin;
  };

  public void out()
 { System.out.println("X : "+x+",Y : "+y+",Z : "+z);
  };

  public void add(vector a,vector b)
  { x=a.x+b.x;
    y=a.y+b.y;
    z=a.z+b.z;
  };

  public void sub(vector a,vector b)
  { x=a.x-b.x;
    y=a.y-b.y;
    z=a.z-b.z;
  }
  public void sub(vector a)
  { x-=a.x;
    y-=a.y;
    z-=a.z;
  }
  public double norm()
  { return x*x+y*y+z*z;
  }
  public void einheit()
  { double hilf=Math.sqrt(x*x+y*y+z*z);
    if (hilf!=0)
    { x=x/hilf;
      y=y/hilf;
	  z=z/hilf;
    }
  };
  public void cross(vector a,vector b)
  { x=a.y*b.z-a.z*b.y; // falls noetig zuerst zwischen speichern
    y=a.z*b.x-a.x*b.z;
    z=a.x*b.y-a.y*b.x;
  }
  public double skalar(vector a)
  { return x*a.x+y*a.y+z*a.z;
  }

  public void Rot(Matrix T,boolean neueAchse)
  { if (neueAchse)
    { double hx=x*T.T[0][0]+y*T.T[0][1]+z*T.T[0][2];
      double hy=x*T.T[1][0]+y*T.T[1][1]+z*T.T[1][2];
      z=x*T.T[2][0]+y*T.T[2][1]+z*T.T[2][2];
      x=hx; y=hy;
    }
    else
    { x=X*T.T[0][0]+Y*T.T[0][1]+Z*T.T[0][2];
      y=X*T.T[1][0]+Y*T.T[1][1]+Z*T.T[1][2];
      z=X*T.T[2][0]+Y*T.T[2][1]+Z*T.T[2][2];
     }   
  }

};

class RGB
{ int R=0,G=0,B=0;
static final int maxdefColor=17;
 static final String Name[]={"GRAY","RED","BLUE","GREEN","BLACK","WHITE","YELLOW",
							 "LIGHTBLUE","DARKGRAY","BROWN","LIGHTGRAY",
                             "PINK","MAGENTA","ORANGE","CYAN",
                             "R","A"};
 static final int Farbe[][]={{128,128,128},{255,0,0},{0,0,255},{0,255,0},{0,0,0},{255,255,255},
				   {255,255,0},{128,128,255},{64,64,64},{220,160,100},{192,192,192},
                   {255,0,255},{0,255,255},{255,200,100},{100,200,255},
                   {255,128,255},{0,50,255}}; 
  public RGB()
  { R=0; G=0; B=0;
  }
  public RGB(int Rin,int Gin,int Bin)
  { R=Rin; G=Gin; B=Bin;
  }
   public RGB(String in)
  { if(in.length()>0 && in.charAt(0)=='{')
    { int Komma1=in.indexOf(',');
      int Komma2=in.indexOf(',',Komma1+1);
	  R=Integer.parseInt(in.substring(1,Komma1));
	  G=Integer.parseInt(in.substring(Komma1+1,Komma2));
	  B=Integer.parseInt(in.substring(Komma2+1));
    } else
      for (int i=0;i<maxdefColor;i++)
	    if (Name[i].equals(in))
	    { R=Farbe[i][0]; G=Farbe[i][1]; B=Farbe[i][2];}
   // System.out.println("RGB :"+in+" = "+R+","+G+","+B);
  }

  public void set(int Rin,int Gin,int Bin)
  { R=Rin; G=Gin; B=Bin;
  }
  public Color abdunkeln(double darkness)
  {   // System.out.println("RGB :"+darkness+","+(int)(R*darkness));
 
    return new Color((int)(R*darkness),(int)(G*darkness),(int)(B*darkness));
  }
  public Color color()
  { return new Color(R,G,B);
  }
}


class face
{ static final int MaxEcken=30;  // pro Flaeche
  int anzahl=0;
  RGB farbeRGB= new RGB();
  Color farbe=Color.black;
  boolean oval=false,fill=true,schonberechnet=false;
  int verts[] = new int[MaxEcken];
  int Eckenx[]=new int[MaxEcken],Eckeny[]=new int[MaxEcken];


  public face(int inverts[],int inanzahl,RGB farbeRGBin)
  { anzahl=inanzahl;
     if (anzahl>=MaxEcken)
       System.out.println("Zuviele Ecken :"+anzahl+"(Max"+MaxEcken+")");
    for (int i=0;i<anzahl;i++)
      verts[i]=inverts[i];
    farbeRGB=farbeRGBin;
  }

  public face(String e,String f)
  { anzahl=0;
	for (int begin=0;begin<e.length() && anzahl<MaxEcken;)
	{ int end=e.indexOf(',',begin);
	  if (end==-1) end=e.length();
	  if (begin!=end)
	  { verts[anzahl++]=Integer.parseInt(e.substring(begin,end));
           // System.out.println("face:"+e+"="+verts[anzahl-1]);
          }
	  begin=end+1;
	}
	farbeRGB=new RGB(f);;
  }


  public void setoval(boolean inoval)
  { oval=inoval;
  }
  public void setfill(boolean infill)
  { fill=infill;
  }
  public vector normal(vector Ecke[])
  { vector hilf1=new vector(), hilf2=new vector(), hilf=new vector();
    hilf1.sub(Ecke[verts[0]],Ecke[verts[1]]);
    hilf2.sub(Ecke[verts[1]],Ecke[verts[2]]);
    hilf.cross(hilf1,hilf2);
    hilf.einheit();
	return hilf;
  }


  public double draw(Graphics g,vector Ecke[],int wox,int woy,int distz,int normdist,
                     vector light,boolean all)
  { if(!schonberechnet)
    for (int i=0;i<anzahl;i++)
	{ double distanz=(Ecke[verts[i]].z+normdist)/(double)distz;
	  Eckenx[i]=(int) (Ecke[verts[i]].x*distanz)+wox;
	  Eckeny[i]=(int) (Ecke[verts[i]].y*distanz)+woy;
	}
	// Sichtbarkeit + Helligkeit (Schatten)
	vector hilf=normal(Ecke);
	schonberechnet=false;
	if (all)
	{ schonberechnet=true;
	  hilf.z=-hilf.z;
        }
// System.out.println("light :"+light.x+","+light.y+","+light.z);

	if (hilf.z>0)
	{ double darkness=(hilf.skalar(light)+1.)/2.f;   
	  farbe= farbeRGB.abdunkeln(darkness);
      g.setColor(farbe);
	  if (oval) // geht natuerlich nur sehr begrenzt
	    if (fill)
		  g.fillOval(Eckenx[0],Eckeny[0],
		          Math.abs(Eckenx[0]-Eckenx[2]),Math.abs(Eckeny[0]-Eckeny[2])+1);
	  else
	   g.drawOval(Eckenx[0],Eckeny[0],
	   Math.abs(Eckenx[0]-Eckenx[2]),Math.abs(Eckeny[0]-Eckeny[2])+1);
	  else if (fill)
  	         g.fillPolygon(Eckenx,Eckeny,anzahl);
	       else 
			 g.drawPolygon(Eckenx,Eckeny,anzahl);
           
        return darkness;
	}
    return -1.;
  }

  public void drawshadow(Graphics g,vector Ecke[],int wox,int woy,int distz,
                         int normdist,vector light,int woEbene,Color Schattenfarbe)
  { int Ex[]=new int [30],Ey[]=new int[30];
    for (int i=0;i<anzahl;i++)
   { double distanz=(Ecke[verts[i]].z+normdist)/(double) distz;
     Eckenx[i]=(int) (Ecke[verts[i]].x*distanz)+wox;
     Eckeny[i]=(int) (Ecke[verts[i]].y*distanz)+woy;
     double faktor =(woEbene-Ecke[verts[i]].z)/light.z;
     Ex[i]=Eckenx[i]+(int)(faktor*light.x);
     Ey[i]=Eckeny[i]+(int)(faktor*light.y);
   }
   schonberechnet=true;
   g.setColor(Schattenfarbe);
   g.fillPolygon(Ex,Ey,anzahl);
  }


  public void  drawaufFlaeche(Graphics g,vector Ecke[],int wox,int woy,int distz,
                              int normdist,vector light,double darkness)
  { for (int i=0;i<anzahl;i++)
	{ double distanz=(Ecke[verts[i]].z+normdist)/(double)distz;
	  Eckenx[i]=(int) (Ecke[verts[i]].x*distanz)+wox;
	  Eckeny[i]=(int) (Ecke[verts[i]].y*distanz)+woy;
	}
	g.setColor(farbeRGB.abdunkeln(darkness));
	if (oval) // geht natuerlich nur sehr begrenzt
	  if (fill)
	    g.fillOval(Eckenx[0],Eckeny[0],		          
              Math.abs(Eckenx[0]-Eckenx[2]),Math.abs(Eckeny[0]-Eckeny[2])+1);
	  else
	    g.drawOval(Eckenx[0],Eckeny[0],				   
              Math.abs(Eckenx[0]-Eckenx[2]),Math.abs(Eckeny[0]-Eckeny[2])+1);    
	else if (fill)
  	       g.fillPolygon(Eckenx,Eckeny,anzahl);
	     else 
	       g.drawPolygon(Eckenx,Eckeny,anzahl);
  }
}

class Matrix
{  double T[][]={{1,0,0},{0,1,0}, {0,0,1}};
   double Tx[][]={{1,0,0},{0,1,0}, {0,0,1}};
   double Ty[][]={{1,0,0},{0,1,0}, {0,0,1}};
   double Tz[][]={{1,0,0},{0,1,0}, {0,0,1}};

  public Matrix() {;}
 
  public void set()
  { for(int y=0;y<3;y++)
      for(int x=0;x<3;x++)
	    T[y][x]= (y==x) ? 1 : 0;
  }

  public void Transform(double[][] TRot)
  { double Hilf[][] = {{0,0,0},{0,0,0},{0,0,0}};
    for (int x=0;x<3;x++)
	  for (int y=0;y<3;y++)
            for (int i=0;i<3;i++)
		  Hilf[y][x]+=T[y][i]*TRot[i][x];
	for (int x=0;x<3;x++)
	  for (int y=0;y<3;y++)
		T[y][x]=Hilf[y][x];
  }
  public void Rotx(double Winkel)
  { Tx[1][1]=Tx[2][2]=Math.cos(Winkel);
    Tx[2][1]=Math.sin(Winkel);
    Tx[1][2]=-Tx[2][1];
    Transform(Tx);
  }
  public void Roty(double Winkel)
  { Ty[0][0]=Ty[2][2]=Math.cos(Winkel);
    Ty[2][0]=Math.sin(Winkel);
    Ty[0][2]=-Ty[2][0];
    Transform(Ty);
  }
  public void Rotz(double Winkel)
  { Tz[0][0]=Tz[1][1]=Math.cos(Winkel);
    Tz[1][0]=Math.sin(Winkel);
    Tz[0][1]=-Tz[1][0];
    Transform(Tz);
  }
};


class object
{ int AnzahlFlaechen=0,AnzahlEcken=0,AnzEckproFl=4,xbase=0,ybase=0;
  int normdistanz=1000,distanz=1000;
  int MaxEcken=100,MaxFlaechen=40,MaxaufFlaeche=10;
  int aufFlaeche[][]= new int[MaxFlaechen][MaxaufFlaeche];
  int AnzahlaufFlaeche[]=new int[MaxFlaechen],woEbene=-50;
  double Rotx=0,Roty=0,Rotz=0,Rotspeed=0.04;
  boolean all=false,neueAchse=true,shadow=false,Rotate=false,Move=false,Jump=false;
  vector Ecken[] =new vector[MaxEcken],light=new vector((int)2,-10,10);
  face Flaechen[] =new face[MaxFlaechen];
  Matrix Tauto=new Matrix();
  Color Schattenfarbe=Color.darkGray;
  String URL[]=new String[MaxFlaechen/2];
  float Parameter[][]={{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0}};
  static final int MaxIndex=7; // Anzahl Parameter pro Richtung

  public object(int inEcken[][],int inAnzahlEcken,int[][] inFlaechen,int inAnzahlFlaechen,int inFarbe[][])
  { int i;
    AnzahlEcken=inAnzahlEcken; AnzahlFlaechen=inAnzahlFlaechen;
	for (i=0;i<AnzahlEcken;i++)
	  Ecken[i]= new vector((double) 
                   inEcken[i][0],inEcken[i][1],inEcken[i][2]);
	for (i=0;i<AnzahlFlaechen;i++)
	  Flaechen[i]= new face(inFlaechen[i],AnzEckproFl,
                new RGB(inFarbe[i][0],inFarbe[i][1],inFarbe[i][2]));
  }
  public object(String Eckenstr,String Flaechenstr,String Farbenstr)
  { int begin=0,end=0,beginFar=0,endFar=0;
	AnzahlEcken=0; AnzahlFlaechen=0;
	while (begin>=0 && AnzahlEcken<MaxEcken)
	{ begin=Eckenstr.indexOf('{',begin);
	  end  =Eckenstr.indexOf('}',begin+1);
          if (begin!=-1)
	  { Ecken[AnzahlEcken++]=new vector(Eckenstr.substring(begin+1,end));
            begin=end+1;
          }
          if (AnzahlEcken>=MaxEcken) 
 	    System.out.println("ERROR Zuviele Ecken");
        }
    begin=0;
	while (begin>=0 && AnzahlFlaechen<MaxFlaechen)
	{ begin=Flaechenstr.indexOf('{',begin);
	  end  =Flaechenstr.indexOf('}',begin+1);
	  endFar  =Farbenstr.indexOf(',',beginFar);
          if(endFar==-1)
             endFar=Farbenstr.length();
	  if (begin!=-1)
	  { Flaechen[AnzahlFlaechen++]=new
                       face(Flaechenstr.substring(begin+1,end),
                       Farbenstr.substring(beginFar,endFar)); 
			begin=end+1;
       if (endFar!=Farbenstr.length())
	      beginFar=endFar+1;
          }
          if (AnzahlFlaechen>=MaxFlaechen) 
	    System.out.println("ERROR Zuviele Flaechen");
	}
  }
  public void setoval(int oval[],int anzahl)
  { for (int i=0;i<anzahl;i++)
	  Flaechen[oval[i]].setoval(true);
  }
  public void setachse(boolean inneueAchse)
  {  neueAchse=inneueAchse;
  }
  public void setnormdistanz(int innormdistanz)
  {  normdistanz=innormdistanz;
  }
  public void changenormdistanz(int in)
  {  normdistanz+=distanz/in;
  }
  public void setrotspeed(double inRotspeed)
  {  Rotspeed=inRotspeed;
     setRotMatrix();
  }
  public void changerotspeed(double in)
  {  Rotspeed*=Rotspeed*in;
     setRotMatrix();
  }
  public void setRotMatrix()
  { Tauto.set();
    if (Rotx!=0) Tauto.Rotx(Rotx*Rotspeed);
	if (Roty!=0) Tauto.Roty(Roty*Rotspeed);
	if (Rotz!=0) Tauto.Rotz(Rotz*Rotspeed);
  }
  public void setRotx(double in)
  {  Rotx+=in;
	 if (Rotx!=0)
	 { Rotate=true;
	   setRotMatrix();
     }
	 else if (Roty==0 && Rotz==0)
		    Rotate=false;
  }
  public void setRoty(double in)
  {  Roty+=in;
	 if (Roty!=0)
	 { Rotate=true;
	   setRotMatrix();
     }
	 else if (Rotx==0 && Rotz==0)
		    Rotate=false;
  }
  public void setRotz(double in)
  {  Rotx+=in;
	 if (Rotz!=0)
	 { Rotate=true;
	   setRotMatrix();
     }
	 else if (Rotx==0 && Roty==0)
		    Rotate=false;
  }
  public void setRotate(double inx,double iny,double inz,double ins)
  {  Rotx=inx; Roty=iny; Rotz=inz; Rotspeed=ins;
	 if (Rotx==0 && Roty==0 && Rotz==0)
	   Rotate=false;
	 else
	 { Rotate=true;
	   setRotMatrix();
     }
  }
  public void setRotate(String instr)
  { int Komma1=instr.indexOf(',');
    int Komma2=instr.indexOf(',',Komma1+1);
	Rotx=Integer.parseInt(instr.substring(0,Komma1));
	Roty=Integer.parseInt(instr.substring(Komma1+1,Komma2));
	Rotz=Integer.parseInt(instr.substring(Komma2+1));
	if (Rotx==0 && Roty==0 && Rotz==0)
	  Rotate=false;
	else
	  Rotate=true;
	if (Rotate)
      setRotMatrix();
  }
  public void setMove(String instr)
  { int begin=0,end=0;
	int Richtung=0;
    while (begin>=0 && Richtung<3)
    { begin=instr.indexOf('{',begin);
      end  =instr.indexOf('}',begin+1);
      int Index=0;
      if (begin!=-1)
      { String e=instr.substring(begin+1,end); 
        for (int start=0;start<e.length() && Index<MaxIndex;)
	    { int ziel=e.indexOf(',',start);
	      if (ziel==-1) ziel=e.length();
          { Parameter[Richtung][Index++]= Integer.parseInt(e.substring(start,ziel));
            start=ziel+1;
          }
	    }
       begin=end+1;
	  }
	  Parameter[Richtung][2]*=Math.PI/180.f;
	  Parameter[Richtung][3]*=Math.PI/180.f;
      Richtung++;
    }
    if (instr.charAt(instr.length()-1)=='N')
	  Move=false;
    else
	  Move=true;
  }
  public void setdistanz(int indistanz)
  {  distanz=indistanz;
  }
   public float getz()
   { return normdistanz/(float)distanz;
   }
   public void setlight(String instr)
  { light=new vector(instr);
    light.einheit();
  }
  public void setshadow(String instr)
  { int Komma=instr.indexOf(',');
   woEbene=Integer.parseInt(instr.substring(0,Komma));
   Schattenfarbe=(new RGB(instr.substring(Komma+1))).color();
   if (Komma>0)
     shadow=true;
   else
     shadow=false;
  }
  public void setxybase(String instr)
  {	int Komma=instr.indexOf(',');
	xbase=Integer.parseInt(instr.substring(0,Komma));
	ybase=Integer.parseInt(instr.substring(Komma+1));
  }
  public void setdraw(String instr)
  { for (int begin=0;begin<instr.length();)
	{ int end=instr.indexOf(',',begin);
	  if (end==-1) end=instr.length();
          if (begin!=end)
	  Flaechen[Integer.parseInt(instr.substring(begin,end))].setfill(false);
	  begin=end+1;
	}
  }
  public void setoval(String instr)
  { for (int begin=0;begin<instr.length();)
	{ int end=instr.indexOf(',',begin);
	  if (end==-1) end=instr.length();
          if (begin!=end)
	  Flaechen[Integer.parseInt(instr.substring(begin,end))].setoval(true);
	  begin=end+1;
	}
  }
  public void setaufFlaeche(String instr)
  { int begin=0,end=0;
    int WelcheFlaeche=0; 
   while (begin>=0 && WelcheFlaeche<MaxFlaechen/2)
    { begin=instr.indexOf('{',begin);
      end  =instr.indexOf('}',begin+1);
      AnzahlaufFlaeche[WelcheFlaeche]=0;
      if (begin!=-1)
      { String e=instr.substring(begin+1,end); 
        for (int start=0;start<e.length() && 
             AnzahlaufFlaeche[WelcheFlaeche]<MaxaufFlaeche;)
	{ int ziel=e.indexOf(',',start);
	  if (ziel==-1) ziel=e.length();
          { aufFlaeche[WelcheFlaeche][AnzahlaufFlaeche[WelcheFlaeche]++]
            = Integer.parseInt(e.substring(start,ziel));
	    start=ziel+1; AnzahlFlaechen--;
          }
	}
	if (AnzahlaufFlaeche[WelcheFlaeche]>=MaxaufFlaeche)
	  System.out.println("ERROR Zuviele Flaechen auf einer Flaeche");
        begin=end+1;
       }
       WelcheFlaeche++;
     }
     if (WelcheFlaeche>=MaxFlaechen/2) 
       System.out.println("ERROR Zuviele Ecken");
   }
  public boolean setURL(String instr)
  { int anzahl=0;
    for (int begin=0;begin<instr.length() && anzahl<AnzahlFlaechen;)
	{ int end=instr.indexOf(',',begin);
	  if (end==-1) end=instr.length();
	  if (begin!=end)
	   URL[anzahl++]=instr.substring(begin,end);
	  begin=end+1;
	}
	if (AnzahlFlaechen<anzahl)
	  System.out.println("ERROR Zuviele URL definiert (bzw. zuwenige Flaechen)");
    if(anzahl>0)
      Jump=true;
    else
      Jump=false;
   return Jump;
  }
  public void setshadow(boolean inshadow)
  {  shadow=inshadow;
  }
  public void setxybase(int xin,int yin)
  {  xbase=xin; ybase=yin;
  }
  public void setMaxFlaechen(int inmax)
  {  AnzahlFlaechen=inmax;
  }
  public void setfill(int fill[],int anzahl)
  { for (int i=0;i<anzahl;i++)
	  Flaechen[fill[i]].setfill(true);
  }
  public void setdraw(int fill[],int anzahl)
  { for (int i=0;i<anzahl;i++)
      Flaechen[fill[i]].setfill(false);
  }
  public void setaufFlaeche(int inFlaeche,int inaufFlaeche[],int inAnzahlaufFlaeche)
  { AnzahlaufFlaeche[inFlaeche]=inAnzahlaufFlaeche;
	for(int i=0;i<AnzahlaufFlaeche[inFlaeche];i++)
      aufFlaeche[inFlaeche][i]=inaufFlaeche[i];
  }
  public void setpaintall(boolean inall)
  { all=inall;
  }
  public void setpaintall(String allstr)
  { if (allstr.equals("TRUE"))
      all=true;
    else
	  all=false;
  }
  public void setStart(String instr)
  { int Komma1=instr.indexOf(',');
    int Komma2=instr.indexOf(',',Komma1+1);
	Matrix T= new Matrix();
        try{
	  T.Rotx(Integer.parseInt(instr.substring(0,Komma1))*Math.PI/180/Rotspeed);
	  T.Roty(Integer.parseInt(instr.substring(Komma1+1,Komma2))*Math.PI/180/Rotspeed);
	  T.Rotz(Integer.parseInt(instr.substring(Komma2+1))*Math.PI/180/Rotspeed);
        }catch(Exception e){System.out.println("ERROR : START Input");};
	Rot(T);
  }

  public void draw(Graphics g)
  { double darkness=0;
	if (shadow)
	  for (int i=0;i<AnzahlFlaechen;i++)
		Flaechen[i].drawshadow(g,Ecken,xbase,ybase,distanz,normdistanz,light,
		                       woEbene,Schattenfarbe);
    if (all)
      for (int i=0;i<AnzahlFlaechen;i++)
	Flaechen[i].draw(g,Ecken,xbase,ybase,distanz,normdistanz,light,true);
	for (int i=0;i<AnzahlFlaechen;i++)
	 { if ((darkness=Flaechen[i].draw(g,Ecken,xbase,ybase,distanz,
               normdistanz,light,false))>=0)
           for (int j=0;j<AnzahlaufFlaeche[i];j++)
           { Flaechen[aufFlaeche[i][j]].drawaufFlaeche(g,Ecken,xbase,ybase,
                                           distanz,normdistanz,light,darkness);
           }
        }
  }
  public void Rot(Matrix T)
  { for (int i=0;i<AnzahlEcken;i++)
	  Ecken[i].Rot(T,neueAchse);
  }
  public void Rot()
  { if (Rotate)
      for (int i=0;i<AnzahlEcken;i++)
	    Ecken[i].Rot(Tauto,neueAchse);
  }
  public boolean Move()
  { Rot();
    if (Move)
    { for(int i=0;i<3;i++)
      { if (Parameter[i][5]!=0)
	  if (Math.abs(Parameter[i][0]-Parameter[i][4])>=
              Math.abs(Parameter[i][5]/2.))
			Parameter[i][0]+=Parameter[i][5];
		if (Parameter[i][6]!=0)
		  Parameter[i][1]*=Parameter[i][6];
		if (Parameter[i][3]!=0)
		{ Parameter[i][2]+=Parameter[i][3];
		  if (Parameter[i][2]>2*Math.PI)
			Parameter[i][2]-=2*Math.PI;
		  else
		    if (Parameter[i][2]<-2*Math.PI)
		      Parameter[i][2]+=2*Math.PI;
                }
	  }
	 xbase=(int)(Parameter[0][0]+Parameter[0][1]*Math.cos(Parameter[0][2]));
	 ybase=(int)(Parameter[1][0]+Parameter[1][1]*Math.cos(Parameter[1][2]));
       distanz=(int)(Parameter[2][0]+Parameter[2][1]*Math.cos(Parameter[2][2]));
	}
	return Rotate || Move;
  }
  public String jump()
  { int wohin=0;
    double auswahl=Flaechen[0].normal(Ecken).z,hilf;
    for (int i=1;i<AnzahlFlaechen;i++)
    { hilf=Flaechen[i].normal(Ecken).z;
      if (hilf>auswahl)
      { auswahl=hilf; wohin=i;
      }
    }
    return URL[wohin];
  }
}

public class rotate extends java.applet.Applet implements Runnable
{ Thread kicker;
  Image imageoffscreen;
  Graphics offscreen;
  ImageObserver imo = null;
  int X=0,Y=0,X0=0,Y0=0,Screenx=200,Screeny=200,Delay=80;
  boolean drag,userPause=false,Jump=false,Mouse=true,Key=true;
  static final long DoubleClickTime=500,WarteZeil=500L;
  static final int MaxObjekte=4;
  long altezeit=0,zeit=0,downzeit=0;
  int MaxFlaechen,NormDistanz=1000,Distanz=1000,AnzahlObjekte=0,w=0;
  double Rotspeed=1;
  String xyBasestring,Shadowstring,aufFlaechestring,Drawstring,URLstring;
  String Farbenstring,Eckenstring,Flaechenstring,Backgroundstring;
  String PaintAllstring,Lichtstring,Movestring,Rotatestring,Objektestring;
  String Startstring,Ovalstring;
  Color Hintergrundcolor=Color.white; 
  String FrameURL="_self";
  int AktuellesObjekt=0,ObjNr=0,PrintRow[]=new int[MaxObjekte];
  Matrix T = new Matrix();
  object Objekt[]= new object[MaxObjekte];

  public String getAppletInfo()
  { return "rotate (c) 23.3.1996 Daniel Abplanalp";
  }

 public void init()
 { Screenx=size().width;
   Screeny=size().height;
   if (Screenx<1) Screenx=200;
   if (Screeny<1) Screeny=200;
   try { imageoffscreen = createImage(Screenx,Screeny);
	    offscreen = imageoffscreen.getGraphics();
      } catch (Exception e)
        { // double-buffering not available
		  offscreen = null;
		}
   resize(Screenx,Screeny);
   
   Objektestring = getParameter("OBJEKTE");
   if (Objektestring==null)
	 Objektestring = "O";
   // System.out.println("Obj",Objektestring);
   for (int begin=0;begin<Objektestring.length() && ObjNr<MaxObjekte;ObjNr++,AnzahlObjekte++)
   { int end=Objektestring.indexOf(',',begin);
	 int GrundObj=-1;
	 if (end==-1) end=Objektestring.length();
	 String ObjStr=Objektestring.substring(begin,end);
     String Objstr,Grundstr=new String("");
	 if (ObjStr.equals("O"))
	   Objstr="";
	 else
	 if ((GrundObj=ObjStr.indexOf('.'))!=-1)
	 { Objstr=ObjStr.substring(0,GrundObj);
	   Grundstr=ObjStr.substring(GrundObj+1);
     }else
       Objstr=ObjStr;
// System.out.println("Grund : ("+Grundstr+"),OStr : "+ObjStr+",str : "+Objstr);

	 Eckenstring = (String) (getParameter("ECKEN"+Objstr));

	 if (Eckenstring==null && GrundObj>=0)
	   	 Eckenstring = (String) (getParameter("ECKEN"+Grundstr));
	 if (Eckenstring==null)
	   Eckenstring = "{-10,-10,-5},{10,-10,-5},{0,10,5}";
	 Flaechenstring = getParameter("FLAECHEN"+Objstr);
 	 if (Flaechenstring==null && GrundObj>=0)
	   	 Flaechenstring = (String) (getParameter("FLAECHEN"+Grundstr));
	if (Flaechenstring==null)
       Flaechenstring = "{0,1,2},{2,1,0}";
	 Farbenstring = getParameter("FARBEN"+Objstr);
	 if (Farbenstring==null && GrundObj>=0)
	   	 Farbenstring = (String) (getParameter("FARBEN"+Grundstr));
	 if (Farbenstring==null)
       Farbenstring = "RED,BLUE";
	 xyBasestring = getParameter("XYBASE"+Objstr);
	 if (xyBasestring==null && GrundObj>=0)
	   	 xyBasestring = (String) (getParameter("XYBASE"+Grundstr));
	 if (xyBasestring==null)
       xyBasestring = "AUTO";
     try {
	  	  MaxFlaechen = Integer.parseInt(getParameter("MAXFLAECHEN"+Objstr));
         } catch(Exception e)
		   { 	 try {
	  	  MaxFlaechen = Integer.parseInt(getParameter("MAXFLAECHEN"+Grundstr));
         } catch(Exception e2)
		 {MaxFlaechen = -1;}}
     try {
			Distanz = Integer.parseInt(getParameter("DISTANZ"+Objstr));
         } catch(Exception e)
		   { try {
			Distanz = Integer.parseInt(getParameter("DISTANZ"+Grundstr));
         } catch(Exception e2)
           {Distanz = 1000;}}
     try {
		    NormDistanz = Integer.parseInt(getParameter("NORMDISTANZ"+Objstr));
         } catch(Exception e)
		   { try {
		    NormDistanz = Integer.parseInt(getParameter("NORMDISTANZ"+Grundstr));
         } catch(Exception e2)
         { NormDistanz = 1000;}}
	 aufFlaechestring = getParameter("AUFFLAECHE"+Objstr);
	 if (aufFlaechestring==null && GrundObj>=0)
	   	 aufFlaechestring = (String) (getParameter("AUFFLAECHE"+Grundstr));
	 if (aufFlaechestring==null)
       aufFlaechestring = "";
     Drawstring = getParameter("DRAW"+Objstr);
	 if (Drawstring==null && GrundObj>=0)
	   	 Drawstring = (String) (getParameter("DRAW"+Grundstr));
	 if (Drawstring==null)
       Drawstring = "";
     Shadowstring = getParameter("SHADOW"+Objstr);
	 if (Shadowstring==null && GrundObj>=0)
	   	 Shadowstring = (String) (getParameter("SHADOW"+Grundstr));
	// if (Shadowstring==null)
      // Shadowstring ="-50,DARKGRAY";
     URLstring = getParameter("URL"+Objstr);
	 if (URLstring==null && GrundObj>=0)
	   	 URLstring = (String) (getParameter("URL"+Grundstr));
	 if (URLstring==null)
       URLstring = "";
	 PaintAllstring = getParameter("PAINTALL"+Objstr);
	 if (PaintAllstring==null && GrundObj>=0)
	   	 PaintAllstring = (String) (getParameter("PAINTALL"+Grundstr));
	 if (PaintAllstring==null)
       PaintAllstring="FALSE";
     Lichtstring = getParameter("LIGHT"+Objstr); // Lichtrichtung
	 if (Lichtstring==null && GrundObj>=0)
	   	 Lichtstring = (String) (getParameter("LIGHT"+Grundstr));
	 if (Lichtstring==null)
       Lichtstring="2,-10,10";
     Movestring = getParameter("MOVE"+Objstr);
	 if (Movestring==null && GrundObj>=0)
	   	 Movestring = (String) (getParameter("MOVE"+Grundstr));
	 if (Movestring==null)
	   Movestring="{0,0,0,0,0,0,0},{0,0,0,0,0,0,0},{0,0,0,0,0,0,0}N";
    // x,y,z=Z+R*cos(a); (mit Z=Z+dS (solang ca. Z<>S); R=R*r; a=a+da;)
    // {Z,R,a,da,S,dS,r} fuer x,y und z
    Rotatestring = getParameter("ROTATE"+Objstr);
	if (Rotatestring==null && GrundObj>=0)
	    Rotatestring = (String) (getParameter("ROTATE"+Grundstr));
	if (Rotatestring==null)
       Rotatestring="0,0,0";
	 Startstring = getParameter("START"+Objstr);
	 if (Startstring==null && GrundObj>=0)
	   	 Startstring = (String) (getParameter("START"+Grundstr));
	 if (Startstring==null)
       Startstring="0,0,0";
	 Ovalstring = getParameter("OVAL"+Objstr);
	 if (Ovalstring==null && GrundObj>=0)
	   	 Ovalstring = (String) (getParameter("OVAL"+Grundstr));
	 if (Ovalstring==null)
	   Ovalstring="";
     try
	 { Rotspeed = Integer.parseInt(getParameter("ROTSPEED"+Objstr))/1000.f;
	 }catch(Exception e)
	  {	 try
	 { Rotspeed = Integer.parseInt(getParameter("ROTSPEED"+Grundstr))/1000.f;
	 }catch(Exception e2)
      {Rotspeed=0.04;}}
	
    Objekt[ObjNr] = new object(Eckenstring,Flaechenstring,Farbenstring);
    if (MaxFlaechen>0)
	  Objekt[ObjNr].setMaxFlaechen(MaxFlaechen);
    Objekt[ObjNr].setnormdistanz(NormDistanz);
    Objekt[ObjNr].setdistanz(Distanz);
    if (xyBasestring.equals("AUTO"))
	  Objekt[ObjNr].setxybase(Screenx/2,Screeny/2);
    else
	  Objekt[ObjNr].setxybase(xyBasestring);
    if (Shadowstring==null)
    { Objekt[ObjNr].setshadow("-50,DARKGRAY");
      Objekt[ObjNr].setshadow(false);
    } 
    else
      Objekt[ObjNr].setshadow(Shadowstring);
    Objekt[ObjNr].setaufFlaeche(aufFlaechestring);
    Objekt[ObjNr].setdraw(Drawstring);
    Objekt[ObjNr].setpaintall(PaintAllstring);
    Objekt[ObjNr].setURL(URLstring);
    Objekt[ObjNr].setachse(true);
	Objekt[ObjNr].setlight(Lichtstring);
	Objekt[ObjNr].setoval(Ovalstring);
	Objekt[ObjNr].setrotspeed(Rotspeed);
	Objekt[ObjNr].setRotate(Rotatestring);
	Objekt[ObjNr].setStart(Startstring);
    Objekt[ObjNr].setMove(Movestring);
	begin=end+1;
   }
   try
   { AktuellesObjekt = Integer.parseInt(getParameter("AKTUELLESOBJEKT"));
   }catch(Exception e)
   { AktuellesObjekt=0;}
   try
   { Delay = Integer.parseInt(getParameter("DELAY"));
   }catch(Exception e)
   { Delay=80;}
   FrameURL = getParameter("FRAME");
   if (FrameURL==null)
     FrameURL = "_self";
   try{
   if(new String(getParameter("MOUSE")).equals("ON"))
      Mouse=true;
    else
      Mouse=false;
    }catch(Exception e)
	  {Mouse=true;}
  try{ 
  if(new String(getParameter("KEBOARD")).equals("ON"))
      Key=true;
    else
      Key=false;
 }catch(Exception e)
	  {Key=true;}

   if (FrameURL==null)
     FrameURL = "_self";
   Backgroundstring = getParameter("BACKGROUND");
   if (Backgroundstring==null)
     Backgroundstring = "WEISS";
     Hintergrundcolor=(new RGB(Backgroundstring)).color();
   //System.out.println("AnzObj : "+AnzahlObjekte);
   for(int i=0;i<AnzahlObjekte;i++)
     PrintRow[i]=i;
   for(int i=0;i<AnzahlObjekte-1;i++)
      for(int j=0;j<i;j++)
        if(Objekt[PrintRow[j]].getz()<Objekt[PrintRow[j+1]].getz())
          PrintRow[j]=PrintRow[j+1]; 
  // for(int i=0;i<AnzahlObjekte;i++)
  //  System.out.println("PrintRow : "+PrintRow[i]);
 
   offscreen.setColor(Hintergrundcolor);
   offscreen.fillRect(0,0,Screenx-1,Screeny-1);
   offscreen.setColor(Color.black);
    repaint();
   }

 public void paint(Graphics g)
 { update(g);
 }
public synchronized void offpaint(Graphics g)
{ for(int i=0;i<AnzahlObjekte-1;i++)
    if(Objekt[PrintRow[i]].getz()>Objekt[PrintRow[i+1]].getz())
    { int dummy=PrintRow[i];
      PrintRow[i]=PrintRow[i+1]; 
      PrintRow[i+1]=dummy;
    }
  offscreen.clipRect(0, 0,Screenx,Screeny);
  offscreen.setColor(Hintergrundcolor);
  offscreen.fillRect(0, 0,Screenx,Screeny);
  for (int i=0;i<AnzahlObjekte;i++)
    Objekt[PrintRow[i]].draw(offscreen); // auf Z-Achase schauen !!!
}
public synchronized void update(Graphics g)
 { // Zeichne aktuelles Bild
 g.drawImage(imageoffscreen, 0, 0, imo);
 }

public void start()
{ if(kicker == null)    // Falls kein thread vorhanden
  { kicker=new Thread(this);        // dann bilde einen
    // kicker.setPriority(kicker.MIN_PRIORITY);
    kicker.start();                 // und starte ihn
  }
}


 public void stop()
{ if (kicker!=null && kicker.isAlive())
     kicker.stop();
  // kicker=null;
}

 public void destroy()
{ if (kicker!=null && kicker.isAlive())
  { kicker.stop();
    kicker.destroy();
  }
  kicker=null;
}
public boolean mouseUp(java.awt.Event evt, int x, int y)
{ // thread Pause Falls Maus in applet nur geklickt wird
  if (evt.when-downzeit<200 && kicker != null && kicker.isAlive()) // && loaded
  { if (userPause)
      kicker.resume();
    else
      kicker.suspend();
    userPause= !userPause;
   }
  if (!Mouse)
     return true;
  // Falls Doppelklick -  Verzweigen nach URL...
  if (Objekt[AktuellesObjekt].Jump && Math.abs(evt.when-altezeit)<500)
  { try{ getAppletContext().showDocument(new URL(Objekt[AktuellesObjekt].jump()),FrameURL);
       } catch (Exception e)
         { System.out.println(e.getMessage());
           e.printStackTrace();
         }
  }
  else altezeit=evt.when;
  drag=false;
  return true;
}

public boolean mouseDown(java.awt.Event evt, int x, int y)
{ X0=x; Y0=y;
  drag=true;
  downzeit=evt.when;
  return true;
}
public boolean mouseDrag(java.awt.Event evt, int x, int y)
{  X=x; Y=y;
  if (!Mouse) 
    return true;
  if (X==X0 && Y==Y0)
    return true;
  if (X!=X0)
    T.Roty((X0-X)*Rotspeed);
  if (Y!=Y0)
    T.Rotx((Y0-Y)*Rotspeed);
  zeit=evt.when;
  Objekt[AktuellesObjekt].Rot(T); 
  T.set();  // da neue Achse (..) 
  offpaint(offscreen);
  repaint();
  X0=x; Y0=y;
  return true;
}
        

public boolean keyDown(java.awt.Event evt, int key)
{ // T.set();
  if(key>=(int)'0' && key<=(int)'9')
  { AktuellesObjekt=key-(int)'0';
	if (AktuellesObjekt>=AnzahlObjekte)
	  AktuellesObjekt=AnzahlObjekte-1;
  }
  if (!Key)
    return true;
  if ((char)key=='d')
     Objekt[AktuellesObjekt].changenormdistanz(-10); // in % von ...distanz
  if ((char)key=='D')
    Objekt[AktuellesObjekt].changenormdistanz(10);
  if ((char)key=='s') Objekt[AktuellesObjekt].setshadow(true);
  if ((char)key=='S') Objekt[AktuellesObjekt].setshadow(false);
  if ((char)key=='x') Objekt[AktuellesObjekt].setRotx(-0.5);
  if ((char)key=='X') Objekt[AktuellesObjekt].setRotx(+0.5);
  if ((char)key=='y') Objekt[AktuellesObjekt].setRoty(-0.5);
  if ((char)key=='Y') Objekt[AktuellesObjekt].setRoty(+0.5);
  if ((char)key=='z') Objekt[AktuellesObjekt].setRotz(-0.5);
  if ((char)key=='Z') Objekt[AktuellesObjekt].setRotz(+0.5);
  if ((char)key==' ')
    Objekt[AktuellesObjekt].setRotate(0.,0.,0.,0.04);
  if ((char)key=='t') Objekt[AktuellesObjekt].changerotspeed(0.5);
  if ((char)key=='T') Objekt[AktuellesObjekt].changerotspeed(2); 
  offpaint(offscreen);
  repaint();
  return  true;
}


 public void run()
 { repaint();
 //  boolean painted=false;
   while (kicker != null) // Solange Thread besteht
   { boolean paint=false;
     for(int i=0;i<AnzahlObjekte;i++)
       if (drag && i==AktuellesObjekt) 
       { if (X==X0 && Y==Y0)
         { // if (evt.when-zeit>WarteZeit)
	       //     T.Rotz(Rotspeed);
           // else 
	       //	   zeit=evt.when;
	     }
	   }
	   else
	     paint=Objekt[i].Move() || paint;   
	 if (paint)
         { offpaint(offscreen);
           repaint();
         }
	// if (userPause)
     //  return;
     try  
	 { Thread.sleep(Delay);
     } catch (InterruptedException e){}
   }
 }
}