/**
 *     DOUBLE BLACK DIAMOND        DOUBLE BLACK DIAMOND
 *
 *         //\\   //\\                 //\\   //\\  
 *        ///\\\ ///\\\               ///\\\ ///\\\
 *        \\\/// \\\///               \\\/// \\\///
 *         \\//   \\//                 \\//   \\//
 *
 *        EXPERTS ONLY!!              EXPERTS ONLY!!
 *
 * This file implements the mapping functions needed to lay out the physical
 * cubes and the output ports on the panda board. It should only be modified
 * when physical changes or tuning is being done to the structure.
 */

<<<<<<< HEAD
final int MaxCubeHeight = 6;
final int NumBackTowers = 16;

public Model buildModel() {

  // Shorthand helpers for specifying wiring more quickly
  final Cube.Wiring WFL = Cube.Wiring.FRONT_LEFT;
  final Cube.Wiring WFR = Cube.Wiring.FRONT_RIGHT;
  final Cube.Wiring WRL = Cube.Wiring.REAR_LEFT;
  final Cube.Wiring WRR = Cube.Wiring.REAR_RIGHT;
  
  // Utility value if you need the height of a cube shorthand
  final float CH = Cube.EDGE_HEIGHT;
  final float CW = Cube.EDGE_WIDTH ;
  
  // Positions for the bass box
  final float BBY = BassBox.EDGE_HEIGHT + BoothFloor.PLEXI_WIDTH;
  final float BBX = 56;
  final float BBZ = 2;

  // The model is represented as an array of towers. The cubes in the tower
  // are represenented relatively. Each tower has an x, y, z reference position,
  // which is typically the base cube's bottom left corner.
  //
  // Following that is an array of floats. A 2-d array contains an x-offset
  // and a z-offset from the previous reference position. Typically the first cube
  // will just be {0, 0}. Each successive cube uses the position of the previous
  // cube as its reference.
  //
  // A 3-d array contains an x-offset, a z-offset, and a rotation about the
  // y-axis.
  //
  // The cubes automatically increment their y-position by Cube.EDGE_HEIGHT.

  // To-Do:  (Mark Slee, Alex Green, or Ben Morrow):   The Cube # is determined by the order in this list.
  // "raw object index" is serialized by running through towermapping and then individual cube mapping below.
  //  We can do better than this.  The raw object index should be obvious from the code-- looking through the
  //  rendered simulation and counting through cubes in mapping mode is grossly inefficient. 

  TowerMapping[] towerCubes = new TowerMapping[] {};
  
  // Single cubes can be constructed directly here if you need them
  Cube[] singleCubes = new Cube[] {
    // new Cube(15, int( Cube.EDGE_HEIGHT), 39, 0, 10, 0,  WRL),     // Back left channel behind speaker
     //new Cube(x, y, z, rx, ry, rz, wiring),
   //new Cube(0,0,0,0,225,0, WRR),
  };

  // The bass box!
  // BassBox bassBox = BassBox.unlitBassBox(BBX, 0, BBZ); // frame exists, no lights
     BassBox bassBox = BassBox.noBassBox(); // no bass box at all
  // BassBox bassBox = new BassBox(BBX, 0, BBZ); // bass box with lights
 
  // The speakers!
  List<Speaker> speakers = Arrays.asList(new Speaker[] {
     // Each speaker parameter is x, y, z, rotation, the left speaker comes first
     // new Speaker(TRAILER_WIDTH - Speaker.EDGE_WIDTH + 8, 6, 3, -15)
  });


  ////////////////////////////////////////////////////////////////////////
  // dan's proposed lattice
        ArrayList<StaggeredTower> scubes = new ArrayList<StaggeredTower>();
        //if (NumBackTowers != 25) exit();
        for (int i=0; i<NumBackTowers/2; i++) scubes.add(new StaggeredTower(
                  (i+1)*CW,                                                                 // x
                  (i % 2 == 0) ? 0 : CH * 2./3.                ,   // y
                 - ((i % 2 == 0) ? 11 : 0) + 80          ,   // z
                 -45, (i % 2 == 0) ? MaxCubeHeight : MaxCubeHeight) );         // num cubes
        
       for (int i=0; i<NumBackTowers/2; i++) scubes.add(new StaggeredTower(
                 (i+1)*CW,                                                                 // x
                 (i % 2 == 0) ? 0 : CH * 2./3.                ,   // y
                - ((i % 2 == 0) ? 0 : 11) + 80 - pow(CH*CH + CW*CW, .5),   // z
                225, (i % 2 == 0) ? MaxCubeHeight : MaxCubeHeight-1) ); 

      // for (int i=0; i<2 ; i++) scubes.add(new StaggeredTower(
      //             (i+1)*CW,                                                                 // x
      //                0             ,   // y
      //            - 0 + 97 - 2*pow(CH*CH + CW*CW, .5),   // z
      //            225,  MaxCubeHeight  ) ); 
        
        ArrayList<Cube> dcubes = new ArrayList<Cube>();
        // for (int i=1; i<6; i++) {
        //         if (i>1) dcubes.add(new Cube(-6+CW*4/3*i             , 0, 0, 0, 0, 0, WRR));        
        //                          dcubes.add(new Cube(-6+CW*4/3*i+CW*2/3., CH*.5, 0, 0, 0, 0, WRR));        
        // }

float current_x_position = 0;
// scubes.add(new StaggeredTower(//tower 1
//       current_x_position,               // x
//        15   ,   // y
//        0  ,   // z
//      45, 6, new Cube.Wiring[] { WFL, WRR, WFL, WRR, WFL, WRR}) );
// current_x_position += 25.25;
// scubes.add(new StaggeredTower(// tower 2
//       current_x_position,               // x
//        0  ,   // y
//        -10.5   ,   // z
//      45, 6, new Cube.Wiring[] { WFR, WFL, WRR, WRR, WFL, WRR}) );
// current_x_position += 25.25;
// scubes.add(new StaggeredTower(//tower 3
//       current_x_position,               // x
//        15   ,   // y
//        0,   // z
//      45, 6, new Cube.Wiring[] { WRR, WFL, WRR, WRR, WFL, WRR}) );
// current_x_position += 25.25;
// scubes.add(new StaggeredTower(//tower 4
//     current_x_position,               // x
//        0,   // y
//        -10.5  ,   // z
//      45, 6, new Cube.Wiring[] { WFL, WRR, WFL, WRR, WFL, WRR}) );
// current_x_position += 28;
// scubes.add(new StaggeredTower(//tower 5
//       current_x_position,               // x
//        15   ,   // y
//        -4.5 ,   // z
//      45, 6, new Cube.Wiring[] { WRR, WFL, WRR, WFL, WRR, WFL}) );
// current_x_position += 28;
// scubes.add(new StaggeredTower(//tower 6
//       current_x_position,               // x
//        0 ,   // y
//        -10.5,   // z
//      45, 6, new Cube.Wiring[] { WFL, WRR, WFL, WRR, WFL, WRR}) );
// current_x_position += 25.25;
// scubes.add(new StaggeredTower(// tower 7
//       current_x_position,               // x
//        15   ,   // y
//       0,   // z
//      45, 6, new Cube.Wiring[] { WRR, WFL, WRR, WFL, WRR, WFL}) );
// current_x_position += 25.25;     
// scubes.add(new StaggeredTower(//tower 8
//       current_x_position,               // x
//        0  ,   // y
//        -10.5 ,   // z
//      45, 6, new Cube.Wiring[] { WFL, WRR, WFL, WRR, WFL, WRR}) );
// current_x_position += 25.25;
// scubes.add(new StaggeredTower(//tower 9
//       current_x_position,               // x
//        15   ,   // y
//        0,   // z
//      45, 6, new Cube.Wiring[] { WFL, WRR, WFL, WRR, WFL, WRR}) );
// current_x_position += 25.25;

// //TOWERS ON DANCE FLOOR
// scubes.add(new StaggeredTower(//tower 10
//       83.75+39+43-124.5,   // x
//       0,   // y
//        -47.5-43,   // z
//      45,  4, new Cube.Wiring[]{ WRR, WFL, WFL, WRR})  ); 
// scubes.add(new StaggeredTower(//tower 11
//       83.75,   // x
//        0,   // y
//        -47.5,   // z
//      45,  4, new Cube.Wiring[]{ WFL, WRR, WRR, WFL})  );  
// scubes.add(new StaggeredTower(//tower 12
//       83.75+39,   // x
//        0,   // y
//        -47.5,   // z
//      45,  4, new Cube.Wiring[]{ WRR, WFL, WFL, WRR})  ); 
// scubes.add(new StaggeredTower(//tower 13
//        83.75+39+43,   // x
//        0,   // y
//        -47.5-43,   // z
//      45,  4, new Cube.Wiring[]{ WFL, WRR, WFL, WRR})  ); 

// scubes.add(new StaggeredTower(// Single cube on top of tower 4
//       42,               // x
//        112   ,   // y
//          72,   // z
//      -10,  1, new Cube.Wiring[]{ WRL})  );  







  //////////////////////////////////////////////////////////////////////
  //      BENEATH HERE SHOULD NOT REQUIRE ANY MODIFICATION!!!!        //
  //////////////////////////////////////////////////////////////////////

  // These guts just convert the shorthand mappings into usable objects
  ArrayList<Tower> towerList = new ArrayList<Tower>();
  ArrayList<Cube> tower;
  Cube[] cubes = new Cube[200];
  int cubeIndex = 1;  
  float px, pz, ny;
  for (TowerMapping tm : towerCubes) {
    px = tm.x;
    ny = tm.y;
    pz = tm.z;
    tower = new ArrayList<Cube>();
    for (CubeMapping cm : tm.cubeMappings) {
      tower.add(cubes[cubeIndex++] = new Cube(px = px + cm.dx, ny, pz = pz + cm.dz, 0, cm.ry, 0, cm.wiring));
      ny += Cube.EDGE_HEIGHT;
    }
    towerList.add(new Tower(tower));
  }

  
  for (Cube cube : singleCubes) {
    cubes[cubeIndex++] = cube;
  }
  for (Cube cube : dcubes) {
    cubes[cubeIndex++] = cube;
  }
  for (StaggeredTower st : scubes) {
    tower = new ArrayList<Cube>();
    for (int i=0; i < st.n; i++) {
      Cube.Wiring w = (i < st.wiring.length) ? st.wiring[i] : WRR;
      tower.add(cubes[cubeIndex++] = new Cube(st.x, st.y + CH* 4/3.*i, st.z, 0, st.r, 0, w));
    }
    towerList.add(new Tower(tower));
  }   

  return new Model(towerList, cubes, bassBox, speakers);
}
=======
static final float SPACING = 27;
static final float RISER = 13.5;
static final float FLOOR = 0;
>>>>>>> 21dffb1b77608cacc57382f3eb6eac3ed16054c3

/**
 * Definitions of tower positions. This is all that should need
 * to be modified. Distances are measured from the left-most cube.
 * The first value is the offset moving NE (towards back-right).
 * The second value is the offset moving NW (negative comes forward-right).
 */
static final float[][] TOWER_CONFIG = new float[][] {
  new float[] { 0, 0, RISER, 4 },
  new float[] { 25, -10, RISER, 4 },
  new float[] { 50, -22.5, FLOOR, 5 },
  new float[] { 17.25, -35.5, FLOOR, 6 },
  new float[] { 43.25, -51.5, RISER, 6 },
  new float[] { 69.25, -56, FLOOR, 6 },
  new float[] { 12.75, -62.5, RISER, 4 },
  new float[] { 38.75, -78.5, FLOOR, 5 },
  new float[] { 65.75, -83, RISER, 5 },  

};

public Model buildModel() {

  List<Tower> towers = new ArrayList<Tower>();
  Cube[] cubes = new Cube[200];
  int cubeIndex = 1;

  float rt2 = sqrt(2);
  float x, y, z, xd, zd, num;
  for (float[] tc : TOWER_CONFIG) {
    x = -tc[1];
    z = tc[0]; 
    y = tc[2];
    num = tc[3];
    if (z < x) {
      zd = -(x-z)/rt2;
      xd = z*rt2 - zd;
    } else {
      zd = (z-x)/rt2;
      xd = z*rt2 - zd;
    }
    List<Cube> tower = new ArrayList<Cube>();
    for (int n = 0; n < num; ++n) {
      Cube cube = new Cube(xd + 24, y, zd + 84, 0, -45, 0);
      tower.add(cube);
      cubes[cubeIndex++] = cube;
      y += SPACING;
    }
    towers.add(new Tower(tower));
  }

  return new Model(towers, cubes);
}