I'm attempting a simple exercise using particle systems and arraylists. I am attempting to simulate fireworks. I want to shoot a ball object, which explodes in to a particle system when it enters a specific zone. I was able to make this work with a single ball object, however now that I'm using an ArrayList, the origin of the ParticleSystem reverts back to what is instantiated in setup. The problem, is that I can't set the origin to the ball location. How do I set origin of the particlesystem, to the location of the ball?

Any help would be much appreciated. Code owes a heavy heavy debt to Shiffman's Nature of Code.

Code is below. 

2. ArrayList balls;
3. 
   
4. ParticleSystem ps;
5. 
   
6. boolean button = false;
7. 
   
8. PVector origin;
9. PVector grav = new PVector(0.0, 0.1);
10. 
    
11. int x = 100;
12. int y = 380;
13. int w = 100;
14. int h = 100;
15. 
    
16. int x1 = 320;
17. int y1 = 150;
18. int w1 = 100;
19. int h1 = 100;
20. 
    
21. void setup() {
22.   size (640,480);
23.   smooth();
24.   PVector a = new PVector(random(3),random(-5)); //acceleration
25.   PVector v = new PVector(2,-5); //velocity
26.   PVector loca = new PVector(50,380); //where the ball starts
27.   balls = new ArrayList();
28.   balls.add(new Ball(a,v,loca));
29.   ps = new ParticleSystem(1, new PVector(height/2, width/2));
30. }
31. 
    
32. void draw() {
33.   background(255);
34.   //balls.applyForce(grav);
35.   if (button) {
36.     for (int i = balls.size() - 1;  i >=0;  i--) {
37.       Ball ball = (Ball) balls.get(i);
38.       if (ball.pop()) {
39.         //  ball.impact = true;
40.         //  if(ball.impact) {
41.         for (int p = 0;p < 10; p++) {
42.          ps.run();
43.          ps.addParticle();
44.         }
45.       }
46.       else {
47.         //        ball.appyForce(grav);
48.         ball.move();
49.         ball.render();
50.       }
51.     }
52.   }
53.   fill(175);
54.   rect(x,y,w,h);
55.   noFill();
56. }
57. 
    
58. void mousePressed() {
59.   if (mouseX > x && mouseX < x+w && mouseY <y+h && mousePressed) {
60.     button = !button;
61.   }
62. }
63. 
    
64. //void explode() {
65.  // for (int i = 0; i < 20; i++) {
66.     //    ps.applyForce(grav);
67.   //  ps.run();
68.   //  ps.addParticle();
69.  // }
70. //}
73. 
    
74. 
    
75. class Particle {
76.   PVector loc;
77.   PVector vel;
78.   PVector acc;
79.   float r;
80.   float timer;
81. 
    
82.   Particle(PVector a, PVector v, PVector l, float r_) {
83.     acc = a.get();
84.     vel = v.get();
85.     loc = l.get();
86.     r = r_;
87.     timer = 100.0;
88.   }
89.   
90.   Particle(PVector l) {
91.     
92.     acc = new PVector(0,0.05,0);
93.     vel = new PVector(random(-1,1),random(-2,0),0);
94.     loc = l.get();
95.     r = 10.0;
96.     timer = 150.0;
97.   }
98.      
99.   void run() {
100.     update();
101.     render();
102.   }
103.  
104.   void update() {
105.     vel.add(acc);
106.     loc.add(vel);
107.     acc = new PVector();
108.     timer -= 2.5;
109.   }
110.   
111.   //I'm bi-winning. Winning here, winning there!
112.   
113.   void render() {
114.     ellipseMode(CENTER);
115.     stroke(0,timer);
116.     fill(0,timer);
117.     ellipse(loc.x,loc.y,r,r);
118.    // point(loc.x,loc.y);
119.   }
120.   
121.  void applyForce(PVector force) {
122.     acc.add(force);
123.   } 
124.  
125.   boolean dead() {
126.     if (timer <= 0.0) {
127.       return true;
128.     } else {
129.       return false;
130.     }
131.   }
132. }
135. //code/comments taken and altered (sorta) from Shiffman's SimpleParticalSystem <http://www.shiffman.net>
136. 
     
137. class ParticleSystem {
138.   
139.   ArrayList particles; //an ArrayList for all the particle 
140.   PVector origin;
141.   
142.   ParticleSystem(int num, PVector l){
143.     particles = new ArrayList();
144.     origin = l.get();
145.     println(origin);
146.     for (int i = 0; i < num; i++) {
147. //      PVector n = new PVector (origin); //store the origin point, the mouseX/mouseY was added by Liesje to demonstrate how to change the origin
148.    //   origin = l.get();
149.       particles.add(new Particle(origin)); //add "num" particles to the array list
150.     }
151.   }
152.   
153.   void run(){
154.     //going backwards through ArrayList because we are deleting
155. 
     
156.     for (int i = particles.size()-1; i >= 0; i--) {
157.       Particle p = (Particle) particles.get(i); //why is it "(Particles)"
158.       p.run();
159.       if (p.dead()){
160.         particles.remove(i); //remove all particles (i)
161.       }
162.     }
163.   }
164.   
165.   void setOrigin(){
166.       for (int i = balls.size() - 1;  i >=0;  i--) {
167.       Ball ball = (Ball) balls.get(i);
168.       origin = ball.loc;
169.       }
170. }
171.   
172.   void addParticle(){
173.     particles.add(new Particle(origin));
174.   }
175.   
176.   void setOrigin(PVector v) {
177.  origin = v.get();
178. }
179.   
180.   void addParticle(Particle p) {
181.     particles.add(p);
182.   }
183.   
184.   boolean dead() {
185.     if (particles.isEmpty()) {
186.       return true;
187.     } else {
188.       return false;
189.     }
190.   }
191. }
192. 
     
194. class Ball {
195.   ArrayList balls; 
196.   PVector loc;
197.   PVector vel;
198.   PVector acc;
199.   float mass = 1.0f;
200. 
     
201.   boolean impact = false; 
202. 
     
203.   Ball(PVector a, PVector v, PVector l) {
204.     acc = a.get();
205.     vel = v.get();
206.     loc = l.get();
207.   }
208. 
     
209.   void update() {
210.     vel.add(acc); //adding velocity to acceleration 
211.     loc.add(vel); //adding location to vel, to create movement
212.     acc.mult(0); //resetting the acceleration back to 0
213.   }
214. 
     
215.   boolean pop() {  //from tank sketch
216.     //if loc.x > 320 and loc x is smaller than 320+100 and loc.y is smaller than 250
217.     // if loc.x is between 320/420 and loc.y is smaller than 250
218.     if (loc.x > x1 && loc.x < x1+w1 && loc.y < y1+h1) { 
219.       //   if(((loc.x > width-200) || (loc.x < 200)) || ((loc.y > height-300) || (loc.y < 200))) {
220.       return true;
221.     }
222.     else return false;
223.     //  (mouseX > x && mouseX < x+w && mouseY <y+h && mousePressed)
224.   }
225.    /*  
226.    void explode() {
227.    for (int i = 0; i < 20; i++) {
228.    ps.applyForce(grav);
229.    ps.addParticle();
230.    }
231.    }
232.    */
233. 
     
234.   PVector getLoc() {
235.     return loc;
236.   }
237. 
     
238.   float getMass() {
239.     return mass;
240.   }
241. 
     
242.   PVector calcGravForce(Ball balls) {
243.     PVector dir = PVector.sub(loc, balls.getLoc());
244.     float d = dir.mag();
245.     dir.normalize();
246.     float force = (G* mass * balls.getMass()) / (d * d);
247.     dir.mult(force);
248.     return dir;
249.   }
250. 
     
251.   void render() {
252.     stroke(0);
253.     fill(0);
254.     ellipse(loc.x,loc.y, mass*20, mass*20);
255.   }
256. 
     
257.   //   void applyForce(PVector force) {
258.   //   acc.add(force);
259.   //} 
260. 
     
261. 
     
262.   void move() {
263.     update();  //do I even need this function?
264. 
     
265.     //TIGERS BLOOD
266. 
     
267.     if(loc.x >width || loc.x < 10) {
268.       vel.x = vel.x * -1;
269.     }
270. 
     
271.     if(loc.y > height || loc.y < -10) {
272.       vel.y = vel.y * -1;
273.     }
274.   }
275.   void applyForce(PVector force) { 
276.     force.div(mass);
277.     acc.add(force);
278.   }
279. }