public class BlueBallRing
{
  public Vector2D Pos;        //The actual position of the barier
  
  private float Orient;       //Orientation of the whole thing
  public int maxBalls;        //Number of balls in the total ring (counting any that have been launched)
  public int BallsRemaining;  //When this equals 0, we're empty
  public float outer_rad;     //radius around which the balls rotate


  public float  ball_radius; //Radii of the balls themselves - if we switch to other reps 
                             //  triangles, etc, this is where we can add extra 
                             

  public Vector2D[] points;            //These are the effective center points of the balls 
  public Vector2D[] StartPoints;       //The precalculated starting points of the balls
  public boolean[] ActiveFlags;   //parallel to "points,"  this tells us whether the balls are active or not
  private float thetaSep;

  BlueBallRing()
  {
    //Basic default values
    maxBalls = 30; 
    BallsRemaining = maxBalls;
    Orient = 0.0f;  //Facing right
    Pos = new Vector2D(300.0f,300.0f);
    outer_rad = 275.0f;
    ball_radius = 5.0f;

     //ok, so loop through the sucker, calculating where the points are.
     float twopi = 6.283185307f;
     thetaSep = twopi/maxBalls;
            
     points = new Vector2D[maxBalls];
     StartPoints = new Vector2D[maxBalls];       
     ActiveFlags = new boolean[maxBalls];       
            
    //Initialization - Kinda slow       
    for (int i=0; i<maxBalls; ++i)
    {
      StartPoints[i] = new Vector2D(outer_rad*(Math.cos(thetaSep*i + Orient)),
                                    outer_rad*(Math.sin(thetaSep*i + Orient)));

      ActiveFlags[i] = true;
      points[i] = new Vector2D(StartPoints[i]);      
    }    

    SetOrientation(Orient);
        
  }

  //Just for debugging, turn all the balls back on
  public void ReloadBalls()
  {
    for (int i=0; i<maxBalls; ++i)
      ActiveFlags[i] = true;
      
    BallsRemaining = maxBalls;
  }

  //Deactivates the ball. Returns false if the ball was already inactive
  //  Also manages the "BallsRemaining" Value
  public boolean DeactivateBall(int Num)
  {
    if (ActiveFlags[Num] == true)
    {
      ActiveFlags[Num] = false;
      --BallsRemaining;  //Decrement Balls remaining
      return true;
    }
    return false;
  }
  
  //input is the point in screen space that we're identifiying
  public int GetSliceNum(Vector2D v)
  {
    Vector2D targ = v.Minus(Pos); //Vector from our position to the target    
    Float angle = new Float((targ.Heading() + Orient)/thetaSep);
    int retVal = angle.intValue()%maxBalls;  

    if (retVal < 0 )
       return (retVal+maxBalls);
    else 
       return retVal;    
  }
  
  //This doesn't exactly return the "closest" ball right now. it returns the next one clockwise
  public int GetClosestPoint(Vector2D v)
  {
    /*
    Vector2D targ = v.Minus(Pos); //Vector from our position to the target    
    Float angle = new Float((targ.Heading() + Orient)/thetaSep);
    int retVal = angle.intValue()%maxBalls;  
    if (retVal < 0 )
       return (retVal+maxBalls);
    else 
       return retVal;
    */
    
    int startVal = GetSliceNum(v);
    int retVal = startVal;
    //Go searching for the closest active ball to this slice
    while (ActiveFlags[retVal] == false)
    {
      retVal++;
      if (retVal == maxBalls)
        retVal = 0;
      if (retVal == startVal)
      {
        //we've completed a full loop, must be empty
        return 0;  //need to signal an empty condition....
      }
    }
            
    return retVal;
  }
 
 
  //Ok, since we're rotating a lot of stuff here, we need to make this somewhat optimized... 
  // This limits everything to two trig funcs and a bunch of dot products per frame
  public float SetOrientation(float o)
  {
     Orient = o;

     float twopi = 6.283185307f;
     while (Orient > twopi)
     {
       Orient -= twopi;
     }
     while (Orient <= 0)
     {
       Orient += twopi;
     }
          
     //probably need to normalize to between 2Pi and Negative 2pi or something like that here
     
     //Calculate basis vectors for the rotated coordinate frame
     Vector2D xPrime = new Vector2D(Math.cos(Orient), Math.sin(Orient));
     Vector2D yPrime = new Vector2D(-xPrime.y, xPrime.x);  //Quick Rotation of 90 degs

     Vector2D temp = new Vector2D(0.0f, 0.0f);
     for (int i=0; i<maxBalls; ++i)
     {
        temp.x = StartPoints[i].Dot(xPrime);
        temp.y = StartPoints[i].Dot(yPrime);
        points[i].Set(Pos.Plus(temp));
     }              
     
     return Orient;
  }


};