class AnchorPoint extends PParticle
{
   AnchorPoint(float _x, float _y, ParticleSystem _physics)
   {
       super(_x, _y, _physics);  
       positions = new PVector[MAX_ANCHOR_HISTORY];
   }
  
   void moveTo(float _x, float _y)
   {
       super.moveTo(_x, _y);
       
       if (numPositions < MAX_ANCHOR_HISTORY)
       {
           if (numPositions == 0) startTime = millis();
           float t = millis() - startTime;
           positions[numPositions] = new PVector(x, y, t);
           numPositions++;
       }  
   }
   
   void update()
   {
       if (0 < numPositions)
       {
           PVector v0 = positions[0];
           PVector v1 = positions[numPositions - 1];
           float d = v1.z - v0.z;
           float t = millis() - v0.z;
           float f = t / d  - int(t / d);
           
           float t0 = f * d;
           
           for (int i = 0; i < numPositions - 1; i++)
               if ((positions[0].z <= t0) && (t0 < positions[i + 1].z))
               {
                   super.moveTo(positions[i].x, positions[i].y);
                   break;
               }
       }
   }

   int startTime;
   int numPositions = 0;
   PVector[] positions;
}

class Anchors
{
    Anchors()
    {
        points = new ArrayList();    
        selectedPoint = null;
    }
    
    void update()
    {
        AnchorPoint p;
        for (int i = 0; i < points.size(); i++)
        {
            p = (AnchorPoint)points.get(i);
            if (p != selectedPoint)
            {
                p.update();
            }
        }      
    }
    
    void render()
    {

        PParticle p;
        for (int i = 0; i < points.size(); i++) 
        {
            p = (PParticle)points.get(i);
            fill(10, 10, 200);            
            noStroke();        
            ellipse(p.x, p.y, 10, 10);

            stroke(255);
            noFill();
            ellipse(p.x, p.y, ANCHOR_ATTACH_RADIUS, ANCHOR_ATTACH_RADIUS);
        }

    }
 
    boolean selectAnchor(float x, float y, float r)
    {
        selectedPoint = null;
        AnchorPoint p;        
        PVector v = new PVector(x, y);
        for (int i = 0; i < points.size(); i++)
        {
            p = (AnchorPoint)points.get(i);        
            if (p.dist(v) < r)
            {
                p.numPositions = 0;
                selectedPoint = p;
                return true;
            }
        }
        return false;      
    }    
    
    void unselectedAnchor()
    {
        selectedPoint = null;      
    }
    
    void setSelectedAnchor(float x, float y)
    {
        if (selectedPoint != null)
        {
            selectedPoint.moveTo(x, y);
            
            
        }
    }    
    
    int getAnchorIndex(PVector v, float r)
    {
        PParticle p;        

        for (int i = 0; i < points.size(); i++)
        {
            p = (PParticle)points.get(i);           
            if (p.dist(v) < r) return i;
        }
        return -1;
    }
    
    void clear()
    {
        PParticle p;
        for (int i = 0; i < points.size(); i++) 
        {
            p = (PParticle)points.get(i);
            p.stopPhysics();
        }
        points.clear();        
    }

    boolean addAnchor(float x, float y)
    {
        AnchorPoint p = new AnchorPoint(x, y, physics);
        p.particle.makeFixed();
        selectedPoint = p;
        points.add(p);
        return true;
    }
    
    PParticle getAnchor(int idx)
    {
        return (PParticle)points.get(idx); 
    }
    
    ArrayList points;
    PParticle selectedPoint;
}