Esfera loca con los toques

Cada vez que se toca la esfera se enloquece

import processing.sound.*;

int Nmax = 200 ; 
float M = 50 ; 
float H = 0.99 ; 
float HH = 0.01 ;
SqrOsc sqr;

float X[] = new float[Nmax+1] ; 
float Y[] = new float[Nmax+1] ; 
float Z[] = new float[Nmax+1] ;
float V[] = new float[Nmax+1] ; 
float dV[] = new float[Nmax+1] ; 
float L ; 
float R = 2*sqrt((4*PI*(200*200)/Nmax)/(2*sqrt(3))) ;
float Lmin ; 
int N ; 
int NN ; 
float KX ; 
float KY ; 
float KZ ; 
float KV ; 
float KdV ; 
int K;


void setup() {

  fullScreen();
  background(0, 0, 0) ;
  noSmooth() ;
  stroke(255, 255, 255);
  fill(50, 50, 50) ;

  sqr = new SqrOsc(this);


  for ( N = 0; N <= Nmax; N++ ) {
    X[N] = random(-1000, +1000) ;
    Y[N] = random(-1000, +1000) ;
    Z[N] = random(-1000, +1000) ;
  }
} 



void draw() {

  background(0, 0, 0) ;


  for ( N = 0; N <= Nmax; N++ ) {
    for ( NN = N+1; NN <= Nmax; NN++ ) {
      L = sqrt(((X[N]-X[NN])*(X[N]-X[NN]))+((Y[N]-Y[NN])*(Y[N]-Y[NN]))) ;
      L = sqrt(((Z[N]-Z[NN])*(Z[N]-Z[NN]))+(L*L)) ;
      if ( L < R ) {
        X[N] = X[N] - ((X[NN]-X[N])*((R-L)/(2*L))) ;
        Y[N] = Y[N] - ((Y[NN]-Y[N])*((R-L)/(2*L))) ;
        Z[N] = Z[N] - ((Z[NN]-Z[N])*((R-L)/(2*L))) ;
        X[NN] = X[NN] + ((X[NN]-X[N])*((R-L)/(2*L))) ;
        Y[NN] = Y[NN] + ((Y[NN]-Y[N])*((R-L)/(2*L))) ;
        Z[NN] = Z[NN] + ((Z[NN]-Z[N])*((R-L)/(2*L))) ;
        dV[N] = dV[N] + ((V[NN]-V[N])/M) ;
        dV[NN] = dV[NN] - ((V[NN]-V[N])/M) ;
        stroke(random(255+(Z[N]/2)), random(255+(Z[N]/2)), random(255+(Z[N]/2))) ; 
        line(X[N]*1.2*(500+V[N])/400+(width/2), Y[N]*1.2*(500+V[N])/400+(height/2), X[NN]*1.2*(500+V[NN])/400+(width/2), Y[NN]*1.2*(500+V[NN])/400+(height/2)) ; // pone en posicion el circulo
      }
      if ( Z[N] > Z[NN] ) {
        KX = X[N] ; 
        KY = Y[N] ; 
        KZ = Z[N] ; 
        KV = V[N] ; 
        KdV = dV[N] ; 
        X[N] = X[NN] ; 
        Y[N] = Y[NN] ; 
        Z[N] = Z[NN] ; 
        V[N] = V[NN] ; 
        dV[N] = dV[NN] ;  
        X[NN] = KX ; 
        Y[NN] = KY ; 
        Z[NN] = KZ ; 
        V[NN] = KV ; 
        dV[NN] = KdV ;
      }
    }
    L = sqrt((X[N]*X[N])+(Y[N]*Y[N])) ;
    L = sqrt((Z[N]*Z[N])+(L*L)) ;
    X[N] = X[N] + (X[N]*(200-L)/(2*L)) ;
    Y[N] = Y[N] + (Y[N]*(200-L)/(2*L)) ;
    Z[N] = Z[N] + (Z[N]*(200-L)/(2*L)) ;
    KZ = Z[N] ; 
    KX = X[N] ;
    Z[N] = (KZ*cos(float((width/2)-mouseX)/20000))-(KX*sin(float((width/2)-mouseX)/20000)) ;
    X[N] = (KZ*sin(float((width/2)-mouseX)/20000))+(KX*cos(float((width/2)-mouseX)/20000)) ;
    KZ = Z[N] ; 
    KY = Y[N] ;
    Z[N] = (KZ*cos(float((height/2)-mouseY)/20000))-(KY*sin(float((height/2)-mouseY)/20000)) ;
    Y[N] = (KZ*sin(float((height/2)-mouseY)/20000))+(KY*cos(float((height/2)-mouseY)/20000)) ;
    dV[N] = dV[N] - (V[N]*HH) ; 
    V[N] = V[N] + dV[N] ; 
    dV[N] = dV[N] * H ;

    float amplitude = map(mouseY, 0, height, 1.0, 0.0);
    sqr.amp(amplitude);

    // Map mouseX from 20Hz to 1000Hz for frequency
    float frequency = map(mouseX, 0, width, 20.0, 1000.0);
    sqr.freq(frequency);

    // Map mouseX from -1.0 to 1.0 for panning the audio to the left or right
    float panning = map(mouseX, 0, width, -1.0, 1.0);
    sqr.pan(panning);
  }
} 



void mousePressed() {

  Lmin =(width/2) ; 
  NN = 0 ;
  for ( N = 0; N <= Nmax; N++ ) {
    L = sqrt(((mouseX-((width/2)+X[N]))*(mouseX-((width/2)+X[N])))+((mouseY-((height/2)+Y[N]))*(mouseY-((height/2)+Y[N])))) ;
    if ( Z[N] > 0 && L < Lmin ) { 
      NN = N ; 
      Lmin = L ;
    }
  }
  if ( K == 0 ) { 
    dV[NN] = -400 ; 
    K = 1 ;

    sqr.play();
  } else { 
    dV[NN] = +400 ; 
    K = 0 ;
    
    sqr.stop();
  }
}