// <applet code="Plasma" width=800 height=600></applet>
// FB - 201003254
// Morphing Plasma Fractal
import java.applet.Applet;
import java.awt.*;
import java.awt.image.*;

public class Plasma extends Applet
{
  Image img;
  // pix will hold the actual image data
  // mat will hold the 2 image data of palette colors
  int pix[], mat[][];
  int red[],green[],blue[];
  int w,h,scr; // scr: 0 or 1 will show the morph direction between the images
  float roughness;
  int steps;   // number of morph steps between the 2 images
  int ctr;     // counter for steps of morph between the 2 images

  public void adjust(int xa,int ya,int x,int y,int xb,int yb)
  {
    int c,d;
    if(mat[w*y+x][scr]==0)
    {
      d=(int)(Math.abs(xa-xb)+Math.abs(ya-yb));
      c=(mat[w*ya+xa][scr]+mat[w*yb+xb][scr])/2+(int)((Math.random()-0.5)*d*roughness);
      c=((int)Math.abs(c))%256;
      mat[w*y+x][scr]=c;
    }
  }

  public void subdivide(int x1,int y1,int x2,int y2)
  {
    int x,y;
    if(!((x2-x1<2) && (y2-y1<2)))
    {
      x=(x1+x2)/2;y=(y1+y2)/2;
      adjust(x1,y1,x,y1,x2,y1);adjust(x2,y1,x2,y,x2,y2);
      adjust(x1,y2,x,y2,x2,y2);adjust(x1,y1,x1,y,x1,y2);
      if(mat[w*y+x][scr]==0)
      {
        mat[w*y+x][scr]=(mat[w*y1+x1][scr]+mat[w*y1+x2][scr]+mat[w*y2+x2][scr]+mat[w*y2+x1][scr])/4;
      }
      subdivide(x1,y1,x,y);subdivide(x,y1,x2,y);
      subdivide(x,y,x2,y2);subdivide(x1,y,x,y2);
    }
  }

  public void init()
  {
    // create a color palette (RGBY)
    red=new int[256];green=new int[256];blue=new int[256];
    for(int i=0;i<256;i++)
    {
        switch((int)(i/64))
        {
            case 0:
                red[i]=(i%64)*3+64;
                green[i]=0;
                blue[i]=0;
                break;
            case 1:
                red[i]=0;
                green[i]=(i%64)*3+64;
                blue[i]=0;
                break;
            case 2:
                red[i]=0;
                green[i]=0;
                blue[i]=(i%64)*3+64;
                break;
            case 3:
                red[i]=(i%64)*3+64;
                green[i]=(i%64)*3+64;
                blue[i]=0;
                break;
        }
    }

    roughness=(float)Math.random()*2+1;
    w=getSize().width;h=getSize().height;
    pix=new int[w*h]; mat=new int[w*h][2];
    ctr=0;steps=256;
    // create the 2 plasma images
    for(scr=0;scr<2;scr++)
    {
      // put random color pixels to the 4 corners
      for(int y=0;y<2;y++)
        for(int x=0;x<2;x++)
          mat[w*y*(h-1)+x*(w-1)][scr]=(int)(Math.random()*256);
      subdivide(0,0,w-1,h-1);
    }
    scr=0;
  }

  public void paint(Graphics g)
  {
    int a,b,c;
    int alpha=255;

    // keep the speed constant between different PCs!
    long t=System.currentTimeMillis();
    while((System.currentTimeMillis()-t)<5) {;}

    // create a new image between the 2 images
    for(int y=0;y<h;y++)
      for(int x=0;x<w;x++)
      {
        a=mat[w*y+x][scr];
        b=mat[w*y+x][1-scr];
        c=(int)(a+(b-a)*((float)(ctr)/steps));
        // convert image data of palette colors to actual image data
        pix[w*y+x]=(alpha<<24)|(red[c]<<16)|(green[c]<<8)|blue[c];
      }

    ctr+=1; ctr%=steps;
    if(ctr==0)
    { 
      // update (re-calculate) one of the images

      // first clear the old image
      for(int y=0;y<h;y++)
        for(int x=0;x<w;x++)
          mat[w*y+x][scr]=0;

      // put random color pixels to the 4 corners
      for(int y=0;y<2;y++)
        for(int x=0;x<2;x++)
          mat[w*y*(h-1)+x*(w-1)][scr]=(int)(Math.random()*256);
      subdivide(0,0,w-1,h-1); // create the new plasma image
      scr=1-scr; // reverse the morph direction
    }

    img=createImage(new MemoryImageSource(w,h,pix,0,w));
    g.drawImage(img,0,0,this);
    repaint();
  }

  public void update(Graphics g) { paint(g); } // no flickering!
}