/** 
 * string.java
 *
 * Title:			string - NMM
 * Description:	
 * @author			akilian
 * @version			
 */



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

import java.lang.Math.*;
import java.util.Vector;
import java.io.*;
import java.net.*;

public class squarereally extends java.applet.Applet implements Runnable{

// IMPORTANT: Source code between BEGIN/END comment pair will be regenerated
// every time the form is saved. All manual changes will be overwritten.
// BEGIN GENERATED CODE
	// member declarations
// END GENERATED CODE

	boolean isStandalone = false;
	Dimension size;
    
    Image buffer;                    						// The off-screen image for double-buffering
    Graphics bufferGraphics;         						// A Graphics object for the buffer
    Thread animator;                 						// Thread that performs the animation
    boolean please_stop;   
	
	float stepper = 0;
	int timer=0;
	int maxstepper = 10000;
	
	int grid = 4;
	int xdim = 200;
	int ydim = 200;
	int offset = 40;
        float cellsize = 400.0f/(float)xdim;   
        
        int last_x=80;
        int last_y=80;
        int last_mx;
        int last_my;
        float off = cellsize/2.0f;
        int right,up,down,left;
        boolean test;
        int randswitch=1;
        Color[] particle = new Color[grid];
        int colcount;
        int count = 0;
	byte[][][] lattice = new byte[ydim][xdim][grid];
	
	byte[][][] storelattice = new byte[ydim][xdim][grid];
	
	// lookup table collision
        byte[][][] table =  {{{0,0,0,0},{0,0,0,0}},
                                {{0,0,0,1},{0,1,0,0}},
                                {{0,0,1,0},{1,0,0,0}},
                                {{0,0,1,1},{1,1,0,0}},
                                {{0,1,0,0},{0,0,0,1}},
                                {{0,1,0,1},{1,0,1,0}},
				{{0,1,1,0},{1,0,0,1}},
				{{0,1,1,1},{1,1,0,1}},
				{{1,0,0,0},{0,0,1,0}},
				{{1,0,0,1},{0,1,1,0}},
				{{1,0,1,0},{0,1,0,1}},
                                {{1,0,1,1},{1,1,1,0}},
                                {{1,1,0,0},{0,0,1,1}},
                                {{1,1,0,1},{0,1,1,1}},
                                {{1,1,1,0},{1,0,1,1}},
                                {{1,1,1,1},{1,1,1,1}}};
                              
	
	
	
	public squarereally () {
	}

	// Retrieve the value of an applet parameter
	public String getParameter(String key, String def) {
		return isStandalone ? System.getProperty(key, def) :
			(getParameter(key) != null ? getParameter(key) : def);
	}

	// Get info on the applet parameters
	public String[][] getParameterInfo() {
		return null;
	}

	// Get applet information
	public String getAppletInfo() {
		return "Applet Information";
	}

	// Initialize the applet
	public void init() {
		try {
			initComponents();
		}
		catch (Exception e) {
			e.printStackTrace();
		}
		// double buffering
		size   = this.size();
		buffer = this.createImage(size.width, size.height);
		bufferGraphics = buffer.getGraphics();
		please_stop = false;
		
                for(int i=0;i<grid;i++) {
                    particle[i] = new Color(0.3f+((float)(i/14.0f)),0f,0f)  ;
                }
                
		for(int j=0;j<ydim;j++) {
			for(int i=0;i<xdim;i++) {
				for(int b=0;b<grid;b++) {
					lattice[j][i][b]=0;
				}
			}
		}
		
		for(int j=0;j<ydim;j++) {
			for(int i=0;i<xdim;i++) {
				for(int b=0;b<grid;b++) {
					storelattice[j][i][b]=0;
				}
			}
		}
		
		
                for(int j=0;j<ydim;j++) {
			for(int i=0;i<xdim;i++) {
				/*for(int b =0;b<grid;b++) {
				if ((Math.random()*1.0)>=0.5)
					lattice[j][i][b]=1;
				else	lattice[j][i][b]=0;
					//System.out.println(lattice[j][i][0]+" "+lattice[j][i][1]+" "+lattice[j][i][2]+" "+lattice[j][i][3]+" "+lattice[j][i][4]+" "+lattice[j][i][5]+" "+" "+table[b][0][0]+" "+table[b][0][1]+" "+table[b][0][2]+" "+table[b][0][3]+" "+table[b][0][4]+" "+table[b][0][5]+" setlattice");
				}*/
                                if (((Math.random()*1.0)>=0.5)){
                                    count+=1;
                                    //lattice[j][i][(int)(Math.random()*5.0)]=1;
                                }
			}
		}
		
		//set full lattice for a square
		for(int j=offset;j<ydim-offset;j++) {
			for(int i=offset;i<xdim-offset;i++) {
				for(int b =0;b<grid;b++) {
					lattice[j][i][b]=1;
					//System.out.println(lattice[j][i][0]+" "+lattice[j][i][1]+" "+lattice[j][i][2]+" "+lattice[j][i][3]+" "+lattice[j][i][4]+" "+lattice[j][i][5]+" "+" "+table[b][0][0]+" "+table[b][0][1]+" "+table[b][0][2]+" "+table[b][0][3]+" "+table[b][0][4]+" "+table[b][0][5]+" setlattice");
				}
			}
		}       
		
                //lattice[50][50][0]=1;
                //lattice[50][50][1]=1;
                //lattice[50][50][2]=1;
                //lattice[50][50][3]=1;
                //lattice[50][50][4]=1;
                //lattice[50][50][5]=1;
                //ttice[50][50][2]=1;
		this.addMouseListener(new MouseAdapter() 
			{
				public void mouseClicked(MouseEvent e) 
					{	
						
						last_mx = e.getX();
						last_my = e.getY();
						
					}
				});
				
		// event model 1.1 mouse listener
		this.addMouseMotionListener(new MouseMotionAdapter() 
		  {
			  public void mouseMoved(MouseEvent e) 
				 {
				     int x = e.getX(), y = e.getY();
				     
				     if ((x>50)&&(x<((xdim-1)*cellsize)+50)&&(y>50)&&(y<((ydim-1)*cellsize)+50)){
				     	
				     	last_x = x-50;
				     	last_y = y-50;
                                        
                                        for(int i=0;i<grid;i++){
                                            lattice[(int)(last_y/cellsize)][(int)(last_x/cellsize)][i]=1;
                                        }
				     }
				     
				   }
			 });	
		
	}

	public void initComponents() throws Exception {
// IMPORTANT: Source code between BEGIN/END comment pair will be regenerated
// every time the form is saved. All manual changes will be overwritten.
// BEGIN GENERATED CODE
		// the following code sets the frame's initial state
		setLocation(new java.awt.Point(0, 0));
		setLayout(null);
		setSize(new java.awt.Dimension(600, 700));
		// event handling

// END GENERATED CODE
	}
	
	public void animate() {
            //randswitch =(randswitch+1)%1;
            if (randswitch==1) randswitch+=1;
            else randswitch=1;
            // collision
            //System.out.println("did this--- "+randswitch);
		for(int j=0;j<ydim;j++) {
			for(int i=0;i<xdim;i++) {
                                //System.out.println("did thisx");
                                // test for scatter cases
                                
                                // CHECK IN LOOKUP TABLE
				for(int s=0;s<16;s++) {
                                    
                                    if(compareIt(lattice[j][i],table[s][0])) {
                                                for(int c=0;c<grid;c++) {
                                                    lattice[j][i][c]=table[s][1][c];
                                                }
                                                break;
						//System.out.println("test");	
					}	
					//System.out.println(lattice[j][i][0]+" "+lattice[j][i][1]+" "+lattice[j][i][2]+" "+lattice[j][i][3]+" "+lattice[j][i][4]+" "+lattice[j][i][5]+" "+" "+table[s][0][0]+" "+table[s][0][1]+" "+table[s][0][2]+" "+table[s][0][3]+" "+table[s][0][4]+" "+table[s][0][5]+" test here");	
					//System.out.println(" ");
                                }
                                
                        }
                }
		
		int wrap =0;
		//transport step - storing
		for(int j=0;j<ydim;j++) {
                    if (j==0) {
                                down = j+1;
                                up = ydim-1;
                   }
                   else if (j==(xdim-1)) {
                                down = 0;
                                up = j-1;
                   }
                   else {
                        down = j+1;
                        up = j-1;
                   }
                   for(int i=0;i<xdim;i++) {
                                if (i==0) {
                                    right = i+1;
                                    left = xdim-1;
                                }
                                else if (i==(xdim-1)) {
                                    right = 0;
                                    left = i-1;
                                }
                                else {
                                    right = i+1;
                                    left = i-1;
                                }
				for(int b =0;b<grid;b++) {
					if(lattice[j][i][b]==1) {
						// assign neighbour
                                                if (b==0)      storelattice[down][i  ][2]=1;
                                                else if (b==1) storelattice[j][left][3]=1;
                                                else if (b==2) storelattice[up  ][i][0]=1;
                                                else if (b==3) storelattice[j][right  ][1]=1;
                                                
						//System.out.println(wrap +" wrap "+ b +" b");
					}
				}
			}
		}
		// write storelattice over lattice
		for(int j=0;j<ydim;j++) {
			for(int i=0;i<xdim;i++) {
				for(int b =0;b<grid;b++) {
					lattice[j][i][b]=storelattice[j][i][b];
					//reset storelattice
					storelattice[j][i][b]=0;
				}
			}
		}
	}
	
        public boolean compareIt(byte[] test1, byte[] test2) {
            
            for(int i=0;i<grid;i++) {
                if (test1[i]!=test2[i]) return false;
            }
            return true;
        }
        
       
        
        
	public void paint(Graphics screen) {
        bufferGraphics.setColor(Color.gray);
        if (stepper ==0)
        bufferGraphics.fillRect(0, 0, size.width, size.height); // clear the buffer
        else bufferGraphics.fillRect((int)(50-cellsize), (int)(50-cellsize), (int)(cellsize+xdim*cellsize),(int)(cellsize+ydim*cellsize)); // clear the buffer 
        
        //shift was 320 for 100 and 4        
       	colcount =0;     
        off =cellsize/2.0f;
        int xpos =0;
       	for(int j=0;j<ydim;j++) {
                        
			for(int i=0;i<xdim;i++) {
				
				//bufferGraphics.setColor(Color.blue);
                                colcount=0;
                                xpos = (int)(i*cellsize)+50;
				for(int b =0;b<grid;b++) {
					if (lattice[j][i][b]==1) {
                                                colcount+=1;
					}
				}
                                //bufferGraphics.setColor(Color.blue);
                                if (colcount==0) {
                                    bufferGraphics.setColor(Color.black);
                                    bufferGraphics.drawRect(xpos,(int)(j*cellsize+50),(int)(cellsize),(int)(cellsize));
                                }
                                //else colcount = colcount-1;
                                //System.out.println(colcount +" colcount");
                                else {
                                    bufferGraphics.setColor(particle[colcount-1]);
                                    bufferGraphics.fillRect(xpos,(int)(j*cellsize+50),(int)(cellsize),(int)(cellsize));
                                }
			}
		}
        
	if (stepper ==0) {	
            
            
		for(int t=0;t<16;t++) {
			for(int a=0;a<2;a++) {
				for(int b=0;b<grid;b++) {
					int size = 8;
					int offsetx=0;
					int offsety=0;
					if (t>31) {
						offsetx = (size+2)*8;
						offsety = -(size+2)*2*32;	
					}
					int centx = 470+a*(size+2)*2+offsetx;
					int centy = 50+t*(size+2)*2+offsety;
					
					if (table[t][a][b]==1) bufferGraphics.setColor(Color.blue);
					else bufferGraphics.setColor(Color.white);
					switch (b) {
						case 0: bufferGraphics.drawLine(centx,centy,centx,centy+size);
						case 1: bufferGraphics.drawLine(centx,centy,centx-size,centy);
						case 2: bufferGraphics.drawLine(centx,centy,centx,centy-size);
						case 3: bufferGraphics.drawLine(centx,centy,centx+size,centy);
						
					}
					//if (a==0) bufferGraphics.drawString(Integer.toString(t),centx-40,centy);
				}
	       	}
       	}
        }
		bufferGraphics.setColor(Color.black);
		screen.drawImage(buffer, 0, 0, this);
	}

 // this one is for updating during runtime	
    Graphics screeng;
    public void update() {
        if (screeng == null) screeng = this.getGraphics();
              paint(screeng);
    }
	public void run() {
        while(!please_stop)
        {
			while (true){
                    animate();
			 		
                    update();
                    stepper +=0.1f;	
                    //System.out.println(stepper);
                }
	 	}
        animator = null;
    }
	public void start() {
        if (animator == null) {
              please_stop = false;
              animator = new Thread(this);
              animator.start();
        }
    }

    // Standard method to stop the applet
    public void stop() 
	{
		please_stop = true;
	}
	// Standard method to destroy the applet
	public void destroy() {
	}

	// Main entry point when running standalone
	public static void main(String[] args) {
		squarereally applet = new squarereally();
		applet.isStandalone = true;
		Frame frame = new Frame();
		frame.addWindowListener(new java.awt.event.WindowAdapter() {
			public void windowClosing(java.awt.event.WindowEvent e) {
				Frame f = (Frame) e.getSource();
				f.setVisible(false);
				f.dispose();
				System.exit(0);
			}
		});
		frame.setTitle("string");
		frame.add( applet, BorderLayout.CENTER );
		applet.init();
		applet.start();
		frame.setSize( 600, 700 );
		Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
		frame.setLocation( (d.width - frame.getSize().width) / 2,
			(d.height - frame.getSize().height) / 2);
		frame.setVisible( true );
	}


/*
    private void initComponents() {//GEN-BEGIN:initComponents
        setLayout(new java.awt.BorderLayout());

    }//GEN-END:initComponents


    // Variables declaration - do not modify//GEN-BEGIN:variables
    // End of variables declaration//GEN-END:variables
*/
}