// Zoaria Node Weights
// August 25, 2005
// David Montie

//**********************************************************************************

float g = 100; // Force Gravity (pull masses together / passive organization)
float cx = 200; //Composite Node Position
float cy = 200; //
float lx; //West Node
float ly; //
float mx; //North Node
float my; //
float nx; //East Node
float ny; //
float ox; //South Node
float oy; //

float cmass = 1;
float lmass = 1;
float mmass = 1;
float nmass = 1;
float omass = 1;

float cxlocked; //Composite Node locked position
float cylocked; //
float lxlocked; //West Node locked position
float lylocked; //
float mxlocked; //North Node locked position
float mylocked; //
float nxlocked; //East Node locked position
float nylocked; //
float oxlocked; //South Node locked position
float oylocked; //

float clweight = 0; // Connection weight
float cmweight = 0;
float cnweight = 0; 
float coweight = 0;
float lmweight = 0;
float lnweight = 0;
float loweight = 0;
float mnweight = 0;
float moweight = 0;
float noweight = 0;

float clgravity = 0; // Connection gravity
float cmgravity = 0;
float cngravity = 0; 
float cogravity = 0;
float lmgravity = 0;
float lngravity = 0;
float logravity = 0;
float mngravity = 0;
float mogravity = 0;
float nogravity = 0;

float lang; // Node motion limiter
float mang; // Node motion limiter
float nang; // Node motion limiter
float oang; // Node motion limiter

float delay = 10.0;
float esize = 4;

boolean coverl = false; // West Node covered?
boolean coverm = false; // North Node covered?
boolean covern = false; // East Node covered?
boolean covero = false; // South Node covered?
boolean coverc = false; // Composite Node covered?

boolean clocked = true; // Composite Node position locked?
boolean llocked = true; // West Node position locked?
boolean mlocked = true; // North Node position locked?
boolean nlocked = true; // East Node position locked?
boolean olocked = true; // South Node position locked?

boolean connectcl = false; // Is there a link between these nodes?
boolean connectcm = false; 
boolean connectcn = false;
boolean connectco = false;
boolean connectlm = false;
boolean connectln = false;
boolean connectlo = false;
boolean connectmn = false;
boolean connectmo = false;
boolean connectno = false;

//**********************************************************************************

void setup() 
{
  size(400, 400);
  noStroke(); 
  smooth();
  ellipseMode(CENTER_RADIUS);  
  
}

//**********************************************************************************

void draw() 
{ 

background(255);

//----------------------------------------------------------------------------------             
                                    
// Northern Triangle

fill(204,153,0,170);
triangle(200, 200, 300, 50, 100, 50);  
      
if (mlocked) {
  ellipse(mxlocked, mylocked, esize + mmass, esize + mmass);
  } else {  
    if(abs(mouseX - mx) > 0.1) {
    mx = mx + (mouseX - mx)/delay;
    }
    if(abs(mouseY - my) > 0.1) {
    my = my + (mouseY- my)/delay;
    }  
}
      
  mang = -1.5*abs(mouseX - 200) + 200;
  mang = constrain (mang, 50, 200);
  mx = constrain(mx, 100, 300);
  my = constrain(my, 50, mang);

  fill(0);
  ellipse(mx, my, esize + mmass, esize + mmass);


//Western Triangle

fill(0,0,81,170);
triangle(200, 200, 300, 350, 100, 350);

if (llocked) {  
  ellipse(lxlocked, lylocked, esize + lmass, esize + lmass);
  } else {
    if(abs(mouseX - lx) > 0.1) {
    lx = lx + (mouseX - lx)/delay;
    }
    if(abs(mouseY - ly) > 0.1) {
    ly = ly + (mouseY - ly)/delay;
    }
}
  lang = -1.5*abs(mouseY - 200) + 200;
  lang = constrain (lang, 50, 200);
  ly = constrain(ly, 100, 300);
  lx = constrain(lx, 50, lang);
  
  fill (0);
  ellipse(lx, ly, esize + lmass, esize + lmass);

  
//Eastern Triangle

fill(153,0,0,170);  
triangle(200, 200, 350, 100, 350, 300);

if (nlocked) {
  ellipse(nxlocked, nylocked, esize + nmass, esize + nmass);
  } else {
    if(abs(mouseX - nx) > 0.1) {
    nx = nx + (mouseX - nx)/delay;
    }
    if(abs(mouseY - ny) > 0.1) {
    ny = ny + (mouseY - ny)/delay;
    }
}    
  nang = 1.5*abs(mouseY - 200) + 200;
  nang = constrain (nang, 200, 350);
  ny = constrain(ny, 100, 300);
  nx = constrain(nx, nang, 350);
  
  fill(0);
  ellipse(nx, ny, esize + nmass, esize + nmass);

    
//Southern Triangle

fill(0,63,0,170);
triangle(200, 200, 50, 100, 50, 300);

if (olocked) {
  ellipse(oxlocked, oylocked, esize + omass, esize + omass);
  } else {
    if(abs(mouseX - ox) > 0.1) {
    ox = ox + (mouseX - ox)/delay;
    }
    if(abs(mouseY - oy) > 0.1) {
    oy = oy + (mouseY - oy)/delay;
    }
}    
  oang = 1.5*abs(mouseX - 200) + 200;
  oang = constrain (oang, 200, 350);
  ox = constrain (ox, 100, 300);
  oy = constrain (oy, oang, 350);
    
  fill(0);
  ellipse(ox, oy, esize + omass, esize + omass);

  
//Composite Node ++++++++++++++++++++++++++++++++++++++++++++++++++

   
cx = (200 + (clweight*lx + cnweight*nx - (200*clweight) - (200*cnweight)) / (2 + clweight + cnweight)) + 
     (cmweight*mx + coweight*ox - 200*cmweight - 200*coweight); 

cy = (200 + (cmweight*my + coweight*oy - (200*cmweight) - (200*coweight)) / (2 + cmweight + coweight)) +
     (clweight*ly + cnweight*ny - 200*clweight - 200*cnweight);
               
    fill(255,255,255,100);
    stroke(0);
    ellipse(cx, cy, 2*(esize + cmass), 2*(esize + cmass));
    noStroke();  
                            

//----------------------------------------------------------------------------------   
      
// Draw Linkages and Calculate Connection Weights

if (connectcl) {
  stroke (0);
  line (cx, cy, lx, ly);
  noStroke();
  clweight = 1; 
  clgravity = g * (cmass * lmass) / sq (dist(cx, cy, lx, ly));
  }

if (connectcm) {
  stroke (0);
  line (cx, cy, mx, my);
  noStroke();
  cmweight = 1; 
  cmgravity = g * (cmass * mmass) / sq (dist(cx, cy, mx, my));
  }

if (connectcn) {
  stroke (0);
  line (cx, cy, nx, ny);
  noStroke();
  cnweight = 1; 
  cngravity = g * (cmass * nmass) / sq (dist(cx, cy, nx, ny));
  }

if (connectco) {
  stroke (0);
  line (cx, cy, ox, oy);
  noStroke();
  coweight = 1; 
  cogravity = g * (cmass * omass) / sq (dist(cx, cy, ox, oy)); 
  }

if (connectlm) {
  stroke (0);
  line (lx, ly, mx, my);
  noStroke();
  lmweight = 1; 
  lmgravity = g * (mmass * lmass) / sq (dist(lx, ly, mx, my));
  }
  
if (connectln) {
  stroke (0);
  line (lx, ly, nx, ny);
  noStroke();
  lnweight = 1; 
  lngravity = g * (nmass * lmass) / sq (dist(lx, ly, nx, ny)); 
  }

if (connectlo) {
  stroke (0);
  line (lx, ly, ox, oy);
  noStroke();
  loweight = 1; 
  logravity = g * (omass * lmass) / sq (dist(lx, ly, ox, oy)); 
  }

if (connectmn) {
  stroke (0);
  line (mx, my, nx, ny);
  noStroke();
  mnweight = 1; 
  mngravity = g * (mmass * nmass) / sq (dist(mx, my, nx, ny)); 
  }                    

if (connectmo) {
  stroke (0);
  line (ox, oy, mx, my);
  noStroke();
  moweight = 1;
  mogravity = g * (omass + mmass) / sqrt (dist(mx, my, ox, oy)); 
  }
                                                                                                                  
if (connectno) {
  stroke (0);
  line (nx, ny, ox, oy);
  noStroke();
  noweight = 1;
  nogravity = g * (omass + nmass) / sqrt (dist(nx, ny, ox, oy)); 
  }
   
}

//**********************************************************************************

void mousePressed() {

int[] mouseposition = {mouseX, mouseY};

//---------------------------------------------------------------------------------- 

// Test if the cursor is over a Western node 
 
  if (mouseposition [0] <= (lx + esize) && mouseposition [0] >= (lx - esize) &&
      mouseposition [1] <= (ly + esize) && mouseposition [1] >= (ly - esize)) {
      coverl = true;
      } else {
      coverl = false; 
      }
      
// Test if the cursor is over a Northern node 
 
  if (mouseposition [0] <= (mx + esize) && mouseposition [0] >= (mx - esize) &&
      mouseposition [1] <= (my + esize) && mouseposition [1] >= (my - esize)) {
      coverm = true;  
      } else {
      coverm = false; 
      }

// Test if the cursor is over a Eastern node 
 
  if (mouseposition [0] <= (nx + esize) && mouseposition [0] >= (nx - esize) &&
      mouseposition [1] <= (ny + esize) && mouseposition [1] >= (ny - esize)) {
      covern = true;  
      } else {
      covern = false; 
      }
                        
// Test if the cursor is over a Southern node 
 
  if (mouseposition [0] <= (ox + esize) && mouseposition [0] >= (ox - esize) &&
      mouseposition [1] <= (oy + esize) && mouseposition [1] >= (oy - esize)) {
      covero = true;  
      } else {
      covero = false; 
      }

// Test if the cursor is over the Composite node

if (mouseposition [0] <= (cx + esize) && mouseposition [0] >= (cx - esize) &&
      mouseposition [1] <= (cy + esize) && mouseposition [1] >= (cy - esize)) {
      coverc = true;  
      } else {
      coverc = false; 
      }

// ------------------------------------------------------------------------------

// Set position of locked Composite Node

  if (coverc) {
    clocked = true;
    cxlocked = mouseposition[0];
    cylocked = mouseposition[1];
    } else {
    //clocked = false;
    }      
    
// Set position of locked Western Node

  if (coverl) {
    llocked = true;
    lxlocked = mouseposition[0];
    lylocked = mouseposition[1];
    } else {
    //llocked = false;
    }      

// Set position of locked Northern Node 

  if (coverm) {
    mlocked = true;
    mxlocked = mouseposition[0];
    mylocked = mouseposition[1];
    } else {
    //mlocked = false;
    }
     
// Set position of locked Eastern Node     
     
  if (covern) {
    nlocked = true;
    nxlocked = mouseposition[0];
    nylocked = mouseposition[1];
    } else {
    //nlocked = false;
    }

// Set position of locked Southern Node    
            
  if (covero) {
    olocked = true;
    oxlocked = mouseposition[0];
    oylocked = mouseposition[1];
    } else {
    //olocked = false;
    }
//----------------------------------------------------------------------------------  
}

void mouseDragged() {
  
    if (coverl) {
      stroke (0);
      line (lx, ly, mouseX, mouseY);
      noStroke ();
      }
      
    if (coverm) {
      stroke (0);
      line (mx, my, mouseX, mouseY);
      noStroke ();
      }
      
    if (covern) {
      stroke (0);
      line (nx, ny, mouseX, mouseY);
      noStroke ();
      }
      
    if (covero) {
      stroke (0);
      line (ox, oy, mouseX, mouseY);
      noStroke ();
      }    
    
}

//********************************************************************************** 

void mouseReleased() {

int[] mousepositionrelease = {mouseX, mouseY};
  
  if (coverc) {
    if (mousepositionrelease [0] <= (lx + esize) && mousepositionrelease [0] >= (lx - esize) &&
        mousepositionrelease [1] <= (ly + esize) && mousepositionrelease [1] >= (ly - esize)) {
        connectcl = true;
        clocked = false;
    } 
    if (mousepositionrelease [0] <= (mx + esize) && mousepositionrelease [0] >= (mx - esize) &&
        mousepositionrelease [1] <= (my + esize) && mousepositionrelease [1] >= (my - esize)) {
        connectcm = true;
        clocked = false;
    }  
    if (mousepositionrelease [0] <= (nx + esize) && mousepositionrelease [0] >= (nx - esize) &&
        mousepositionrelease [1] <= (ny + esize) && mousepositionrelease [1] >= (ny - esize)) {
        connectcn = true;
        clocked = false;
    }
    if (mousepositionrelease [0] <= (ox + esize) && mousepositionrelease [0] >= (ox - esize) &&
        mousepositionrelease [1] <= (oy + esize) && mousepositionrelease [1] >= (oy - esize)) {
        connectco = true;
        clocked = false;
    }
    
 // Add mass to the node
 
    if (mousepositionrelease [0] <= (cx + esize) && mousepositionrelease [0] >= (cx - esize) &&
        mousepositionrelease [1] <= (cy + esize) && mousepositionrelease [1] >= (cy - esize)) {
        cmass = cmass + 1;
        clocked = false;  
        } 
  }
  
  if (coverl) {
    if (mousepositionrelease [0] <= (mx + esize) && mousepositionrelease [0] >= (mx - esize) &&
        mousepositionrelease [1] <= (my + esize) && mousepositionrelease [1] >= (my - esize)) {
        connectlm = true;
        llocked = false;
    }  
    if (mousepositionrelease [0] <= (nx + esize) && mousepositionrelease [0] >= (nx - esize) &&
        mousepositionrelease [1] <= (ny + esize) && mousepositionrelease [1] >= (ny - esize)) {
        connectln = true;
        llocked = false;
    }
    if (mousepositionrelease [0] <= (ox + esize) && mousepositionrelease [0] >= (ox - esize) &&
        mousepositionrelease [1] <= (oy + esize) && mousepositionrelease [1] >= (oy - esize)) {
        connectlo = true;
        llocked = false;
    }
    if (mousepositionrelease [0] <= (cx + esize) && mousepositionrelease [0] >= (cx - esize) &&
        mousepositionrelease [1] <= (cy + esize) && mousepositionrelease [1] >= (cy - esize)) {
        connectcl = true;
        llocked = false;
    }
    
 // Add mass to the node
    
    if (mousepositionrelease [0] <= (lx + esize) && mousepositionrelease [0] >= (lx - esize) &&
        mousepositionrelease [1] <= (ly + esize) && mousepositionrelease [1] >= (ly - esize)) {
        lmass = lmass + 1;
        llocked = false;
        } 
  }
  
  if (coverm) {
    if (mousepositionrelease [0] <= (lx + esize) && mousepositionrelease [0] >= (lx - esize) &&
        mousepositionrelease [1] <= (ly + esize) && mousepositionrelease [1] >= (ly - esize)) {
        connectlm = true;
        mlocked = false;
    }  
    if (mousepositionrelease [0] <= (nx + esize) && mousepositionrelease [0] >= (nx - esize) &&
        mousepositionrelease [1] <= (ny + esize) && mousepositionrelease [1] >= (ny - esize)) {
        connectmn = true;
        mlocked = false;
    }
    if (mousepositionrelease [0] <= (ox + esize) && mousepositionrelease [0] >= (ox - esize) &&
        mousepositionrelease [1] <= (oy + esize) && mousepositionrelease [1] >= (oy - esize)) {
        connectmo = true;
        mlocked = false;
    }
    if (mousepositionrelease [0] <= (cx + esize) && mousepositionrelease [0] >= (cx - esize) &&
        mousepositionrelease [1] <= (cy + esize) && mousepositionrelease [1] >= (cy - esize)) {
        connectcm = true;
        mlocked = false;
    }
    
// Add mass to the node

    if (mousepositionrelease [0] <= (mx + esize) && mousepositionrelease [0] >= (mx - esize) &&
        mousepositionrelease [1] <= (my + esize) && mousepositionrelease [1] >= (my - esize)) {
        mmass = mmass + 1;
        mlocked = false;
        }  
    }
  
  if (covern) {
    if (mousepositionrelease [0] <= (mx + esize) && mousepositionrelease [0] >= (mx - esize) &&
        mousepositionrelease [1] <= (my + esize) && mousepositionrelease [1] >= (my - esize)) {
        connectmn = true;
        nlocked = false;
    }  
    if (mousepositionrelease [0] <= (lx + esize) && mousepositionrelease [0] >= (lx - esize) &&
        mousepositionrelease [1] <= (ly + esize) && mousepositionrelease [1] >= (ly - esize)) {
        connectln = true;
        nlocked = false;
    }
    if (mousepositionrelease [0] <= (ox + esize) && mousepositionrelease [0] >= (ox - esize) &&
        mousepositionrelease [1] <= (oy + esize) && mousepositionrelease [1] >= (oy - esize)) {
        connectno = true;
        nlocked = false;
    }
    if (mousepositionrelease [0] <= (cx + esize) && mousepositionrelease [0] >= (cx - esize) &&
        mousepositionrelease [1] <= (cy + esize) && mousepositionrelease [1] >= (cy - esize)) {
        connectcn = true;
        nlocked = false;
    }
    
// Add mass to the node

  if (mousepositionrelease [0] <= (nx + esize) && mousepositionrelease [0] >= (nx - esize) &&
        mousepositionrelease [1] <= (ny + esize) && mousepositionrelease [1] >= (ny - esize)) {
        nmass = nmass + 1; 
        nlocked = false;
        }
  }
  
  if (covero) {
    if (mousepositionrelease [0] <= (mx + esize) && mousepositionrelease [0] >= (mx - esize) &&
        mousepositionrelease [1] <= (my + esize) && mousepositionrelease [1] >= (my - esize)) {
        connectmo = true;
        olocked = false;
    }  
    if (mousepositionrelease [0] <= (nx + esize) && mousepositionrelease [0] >= (nx - esize) &&
        mousepositionrelease [1] <= (ny + esize) && mousepositionrelease [1] >= (ny - esize)) {
        connectno = true;
        olocked = false;
    }
    if (mousepositionrelease [0] <= (lx + esize) && mousepositionrelease [0] >= (lx - esize) &&
        mousepositionrelease [1] <= (ly + esize) && mousepositionrelease [1] >= (ly - esize)) {
        connectlo = true;
        olocked = false;
    }
    if (mousepositionrelease [0] <= (cx + esize) && mousepositionrelease [0] >= (cx - esize) &&
        mousepositionrelease [1] <= (cy + esize) && mousepositionrelease [1] >= (cy - esize)) {
        connectco = true;
        olocked = false;
    }
 
// Add mass to the node

    if (mousepositionrelease [0] <= (ox + esize) && mousepositionrelease [0] >= (ox - esize) &&
        mousepositionrelease [1] <= (oy + esize) && mousepositionrelease [1] >= (oy - esize)) {
        omass = omass + 1; 
        olocked = false; 
        }

    }

}

//**********************************************************************************