Hey Folks,

I am trying to draw Traer Particles on Points.
The points are generated with a noisy Agent class, which is storing them in a Arraylist.
In draw I refer to the arraylist to define the position of the Particles.
Then i draw ellipses on the particles.
Allright so far.

Moreover i made a particle on the mouseposition, which attracts the Ellipsed Particles.

Why does the physic not work?

Sorry for this much code, but I reduced it to the max.

1. //  ----------------------------------------------------------------------------------------  //
2. //  -- 0. Imports & Variables --------------------------------------------------------------  //
3. //  ----------------------------------------------------------------------------------------  //
4.    //  Imports
5.    //  -------
6.      
7.      
8.        import processing.opengl.*;
9.       
   
10.       
11.        import traer.physics.*;
12.          ParticleSystem physics;
13.         
14.          Particle[] mouse;
15.          //
16.         
17.    //  Variables
18.    //  ---------
19.         
20.    //  ------- steemers -------  //
21.      
22.        Steemer1[] steemers1 = new Steemer1[5000];
23.          //
24.   
25.    //  ------- steemers attributes -------  //
26.      
27.        int steemersCount = 1;
28.        float twirlScale = 750, twirlComplexity = 25,  twirlZRange = 4.5;
29.        float overlayAlpha = 0, steemersAlpha = 15.8, steemersWidth = 0.4;
30.          //
31.    //  ------- fader -------  //
32.       
33.        float gradient = 255, gradientCount = 0;
34.        int dir = 1;
35.          //
36.   
37.   
38.    //  ------- physics -------  //
39.       
40.        float grav = 10;                       //GLOBALE GRAVITATION (std 0)
41.        float drag = 0.6;                      //GLOBALER LUFTWIDERSTAND (std 0.5)
42.       
43.        //  EIGENSCHAFTEN DER PARTIKEL
44.       
45.        float traegheit = 5;                 //PARTIKELTRÄGHEIT (std 5)
46.        float PSchwer = 1000000;                //ANZIEHUNG AN URSPRÜNGLICHE POSITION (std 1000000)
47.        float PMinDist = 280;                 //Traegheit
48.       
49.        //  EIGENSCHAFTEN DER MAUS
50.       
51.        float MSchwer =  -6100;               //ANZIEHUNG AN MAUS 
52.        float MMinDist = 10;                  //MINIMALE DISTANZ DER ANZIEHUNG DER MAUS (std 1)
53.    
54.     //  ------- Global -------  //
55.         int initSetup = 0;  
56.         ArrayList myListX;
57.         ArrayList myListY;
58.         ArrayList Punkte;
59.         PVector vector;
60.         Punkt[] punktSammlung_a;
61.        
62.         ArrayList winkelArray;
63. //  ----------------------------------------------------------------------------------------  //
64. //  -- 1. Hauptkonstruktor -----------------------------------------------------------------  //
65. //  ----------------------------------------------------------------------------------------  //
66.   
67.    //  function setup()
68.    //  ----------------
69.        void setup(){
70.          size(1280,800,OPENGL);
71. //         hint(DISABLE_OPENGL_2X_SMOOTH);     // Turn ON if the graphic sucks
72. //         hint(DISABLE_DEPTH_TEST);           // Turn ON if the graphic sucks
73.          hint(ENABLE_OPENGL_4X_SMOOTH);      // Turn OFF if the graphic sucks
74.  
75.          background(15);
76.          Punkte = new ArrayList();
77.         
78.          winkelArray = new ArrayList();
79.          for(int i=0; i<steemers1.length; i++) {
80.            steemers1[i] = new Steemer1();
81.            }//END for
82. ///////////// PHYSICS
83.         
84.          physics = new ParticleSystem(grav,drag);
85.          mouse = new Particle[5];
86.           
87.            mouse[0] = physics.makeParticle(-100000, -10000, 0, 0.0);
88.            
89.             mouse[0].setMass(500000);
90.             mouse[0].makeFixed();
91.         
92.            punktSammlung_a = new Punkt[steemersCount];
93.         
94.        }//END void setup()
95. void draw(){
96.  overlayAlpha = 0;
97.  
98.  background(0);
99.  fill(0, overlayAlpha);
100.  noStroke();
101.  rect(0,0,width,height);
102.  stroke (gradient, steemersAlpha);
103.  strokeWeight(steemersWidth);
104.  
105.  physics.tick(4);
106.  
107.  if (initSetup < 1) {
108.    punktSammlung_a = new Punkt[10000];
109.  }
110.  initSetup++;
111.  
112.    mouse[0].position().set( mouseX, mouseY, 0 );  //Set nouse particle
113.               
114.     gradientCount = gradientCount + 1; 
115. /////// draw agents /////////////////
116.     for(int i=0; i<steemersCount; i++) {
117.      steemers1[i].update1();      
118.     }
119.    
120.    
121. ///////////draw PARTICLES (DEFINED in agent class
122.     for(int j=0; j<Punkte.size(); j++) {
123.      vector = (PVector)Punkte.get(j);
124.      //vector = new Punkt(vector.x,vector.y);
125.      //println( vector.x );
126.      punktSammlung_a[j] = new Punkt(vector.x,vector.y);   
127.    
128.     
129.     ellipse(punktSammlung_a[j].base.position().x(),punktSammlung_a[j].base.position().y(),22,22);
130.     ellipse(punktSammlung_a[j].fly.position().x(),punktSammlung_a[j].fly.position().y(),15,15);
131.  
132.       }   //println(gradientCount) ;
133.  
134.   fill(255,0,0,255);
135.   ellipse(mouseX,mouseY,10,10);
136. }
137. //  ----------------------------------------------------------------------------------------  //
138. //  -- X.X HELPER --------------------------------------------------------------------------  //
139. //  ----------------------------------------------------------------------------------------  //
140. String timestamp() {
141.  return String.format("%1$ty%1$tm%1$td_%1$tH%1$tM%1$tS", Calendar.getInstance());
142.  }
143.  class Steemer1 {
144.   PVector p, pOld;
145.   float stepSize, angle, m;
146.   boolean isOutside = false;
147.   float twirlZ, twirlZVelocity = 0.004;
148.   Steemer1() {
149.     p = new PVector(random(-100,100)+(width/2),700);
150.     pOld = new PVector(p.x,p.y);
151.     stepSize = 1;
152.     // init twirlZ
153.     setTwirlZRange(0.4);
154.   }
155.   void update1() {
156.     angle = noise(p.x/twirlScale,p.y/twirlScale,twirlZ) * twirlComplexity;
157.    
158.     winkelArray.add(angle); // add in arrayList
159.     //println(winkelArray.get(winkelArray.size()-1));
160.    
161.    
162.     m = map(angle, 0, 360, 0, 140);
163.     p.x += cos(m) * stepSize;
164.     p.y += sin(m) * stepSize;
165.     // add to arrayList
166.     Punkte.add(new PVector(p.x, p.y));
167.     //println(Punkte.get(Punkte.size()-1));
168.     //println(Punkte);
169.    
170.     //println(Punkte.get);   
171.  
172.   /////////// ANGLETEST //////////////
173.  
174.     if (p.y > pOld.y) {
175.       p.y = 2*pOld.y - p.y;
176.     }
177.    
178.     ///////////////////CLEAR ARRAYLIST ////////////////
179.     if (p.y < 200) {
180.       Punkte.clear();
181.       //println("cleared");
182.     }
183.     pOld.set(p);
184.     twirlZ += twirlZVelocity;
185.     isOutside = false;
186.   }
187.   void setTwirlZRange(float theTwirlZRange) {
188.     // small values will increase grouping of the agents
189.     twirlZ = noise(theTwirlZRange);
190.   }
191.  }
192. class Punkt {
193.   Particle fly;
194.   Particle base;
195.   float x;
196.   float y;
197.   Punkt(float _x,   float _y ) {
198.     x = _x;
199.     y = _y;
200.     fly = physics.makeParticle(traegheit, x, y, 90);
201.     base  = physics.makeParticle(1,x,y,8);
202.     base.makeFixed();  
203.     physics.makeAttraction(fly, base, PSchwer,PMinDist);
204.     physics.makeAttraction(fly, mouse[0],  MSchwer, MMinDist);
205.    
206.    
207.   }
208. }