/*
 * pMapGen.java
 *
 * (C) 2005, Alex S.
 */

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

/**
 * random map generator
 */
public class pMapGen {

    /*
     * drop cube 
     */
    public static pBrush dropCube(pMatrix matrix,Color color){
        Vector cube = new Vector();

        // initialize cube
        Vector v_points = new Vector();
        Vector v_faces = new Vector();
        v_points.addElement(new double[]{1,-1,1,1});
        v_points.addElement(new double[]{1,1,1,1});
        v_points.addElement(new double[]{-1,1,1,1});
        v_points.addElement(new double[]{-1,-1,1,1});
        v_points.addElement(new double[]{1,-1,-1,1});
        v_points.addElement(new double[]{1,1,-1,1});
        v_points.addElement(new double[]{-1,1,-1,1});
        v_points.addElement(new double[]{-1,-1,-1,1});
        v_faces.addElement(new int[]{0,1,2,3});
        v_faces.addElement(new int[]{4,7,6,5});
        v_faces.addElement(new int[]{0,4,5,1});
        v_faces.addElement(new int[]{7,3,2,6});
        v_faces.addElement(new int[]{1,5,6,2});
        v_faces.addElement(new int[]{0,3,7,4});


        pBrush brush = new pBrush();
        for (int f=0;f<v_faces.size();f++) {
            int[] arr = (int[])v_faces.elementAt(f);
            pFace face = new pFace();
            pWinding winding = face.winding;
            for (int p=0;p<4;p++) {
                double[] point_ = (double[])v_points.elementAt(arr[p]);
                double[] point = new double[point_.length];
                System.arraycopy(point_,0,point,0,point_.length);
                point = matrix.mult(point);
                winding.x[p] = point[0];
                winding.y[p] = point[1];
                winding.z[p] = point[2];
            }
            winding.size = 4;
            double[] p0 = {winding.x[0],winding.y[0],winding.z[0],1};
            double[] p1 = {winding.x[1],winding.y[1],winding.z[1],1};
            double[] p2 = {winding.x[2],winding.y[2],winding.z[2],1};
            double[] p3 = {winding.x[3],winding.y[3],winding.z[3],1};                            
            pVector.planeFromPoints(face.plane.p,p0,p1,p2,p3);
            face.color = color;
            brush.faces[brush.numFaces++] = face;
        }
        return brush;
    }


    /**
     * generates a random cube based `map'
     */
    public static pMap generateCubes(int n){

        pMap map = new pMap();

        pMatrix matrix = new pMatrix();
        double a,b,c;
        for (int i=0;i<n;i++) {
            for (int j=0;j<n;j++) {
                for (int k=0;k<n;k++) {
                    if ((i ^ j ^ k) % 2 == 0) {

                        //System.out.println("i:"+i+"; j:"+j+"; k:"+k);

                        matrix.push();
                        matrix.translate((i-n/2)*256,(j-n/2)*256,(k-n/2)*256);
                        matrix.scale(64);

                        matrix.rotatex(Math.random()*Math.PI*2);
                        matrix.rotatey(Math.random()*Math.PI*2);
                        matrix.rotatez(Math.random()*Math.PI*2);

                        map.brushes.addElement(
                                              dropCube(matrix,
                                                       new Color(
                                                                (int)(0xFF*i/(double)n),
                                                                (int)(0xFF*j/(double)n),
                                                                (int)(0xFF*k/(double)n)
                                                                )                        
                                                      )
                                              );                        
                        matrix.pop();
                    }
                }
            }
        }

        matrix.push();
        matrix.translate(0,-n*256,0);
        matrix.scale(64*n*2,32,64*n*2);
        map.brushes.addElement(dropCube(matrix,Color.green));
        matrix.pop();

        return map;
    }


    /**
     * generates a random cube based `map'
     */
    public static pMap generateRoundedCubes(double rad, int levels){

        pMap map = new pMap();
        pMatrix matrix = new pMatrix();

        
        for(int i=0;i<levels;i++){
            matrix.push();
            matrix.translate(0,(i-levels/2.0)*300.0,0);
            for(double theta = 0; theta < Math.PI*2; theta += Math.PI / 6){

                if(Math.random() > 0.9)
                    continue;

                double sin = Math.sin(theta);
                double cos = Math.cos(theta);
                matrix.push();

                matrix.rotatey(theta);
                matrix.scale(32,128,256 + 256 * (i/(double)levels));
                matrix.translate(rad + rad * (i/(double)levels),0,0);

                matrix.rotatez(-Math.PI/3 * (i/(double)levels));

                map.brushes.addElement(
                                      dropCube(matrix,
                                               new Color(
                                                        (int)(0xFF*i/(double)levels),
                                                        (int)(0xFF*(sin+1)/2),
                                                        (int)(0xFF*(cos+1)/2)
                                                        )                        
                                              )
                                      );                        
                matrix.pop();
            }
            
            matrix.pop();
        }

        
        matrix.push();        
        matrix.translate(0,(-levels/2.0)*300 - 300.0,0);
        for(int i=10;i>4;i--){
            matrix.translate(0,+256,0);
            matrix.rotatey(Math.PI/4);
            matrix.push();
            matrix.scale(i*50,16,i*50);
            map.brushes.addElement(dropCube(matrix,            
                                               new Color(
                                                        (int)(0xFF*i/11.0),
                                                        (int)(0xFF*i/11.0),
                                                        (int)(0xFF*i/11.0)
                                                        )                        
                                              )
            );
            matrix.pop();
        }
        matrix.pop();

        matrix.push();
        matrix.scale(10,1100,10);
        map.brushes.addElement(dropCube(matrix,Color.black));
        matrix.pop();
        

        return map;
    }



}