I wrote a simple particle simulation program that has blue circles flying around the screen and colliding into each other. When two circles collide I want to display an "explosion" movie (currently implemented as a Movie object) at the location of the collision. 

However, I can't get the full movie to display when the two circles collide - sometimes I don't see anything, and sometimes only a few random frames play. Has anyone done this before or know if there is a very specific way I need to display movie data? This is my first project so please bear with me.

Here is the "test" class, basically the main function in the program:

2. import processing.video.*;
3. import gifAnimation.*;
4. 
   
5. PointSystem ps;
6. String gifFileName = "explosion_animated_gif.gif";
7. String movFileName = "explosion.mp4";
8. Movie explosion;
9. Gif gifExp;
10. int counter = 0;
11. 
    
12. void setup(){
13.   size(displayWidth/2,displayHeight/2);
14.   frameRate(100);
15.   explosion = new Movie(this, movFileName);
16.   explosion.loop();
17.   explosion.play();
18.   println(explosion.duration());
19.   ps = new PointSystem(40, explosion);
20. }
21. 
    
22. void draw(){
23.   background(0);
24.   ps.run();
25. }
26. 
    
27. void movieEvent(Movie m){
28.   m.read();
29. }

Here is the "Point" class - the class that contains the code for the blue circles : 

2. import java.util.Iterator;
3. import processing.video.*;
4. 
   
5. 
   
6. class Point {
7. 
   
8.   PVector velocity;
9.   PVector gravity = new PVector(0, 0.01);
10.   float speedx;
11.   float speedy;
12.   PVector direction;
13.   PVector location;
14.   float xpos;
15.   float ypos;
16.   float angle;
17.   PShape p;
18.   boolean isAlive;
19.   boolean inCollision;
20. 
    
21.   Point() {
22.     xpos = random(width);
23.     ypos = random(height);
24.     location = new PVector(xpos, ypos);
25.     speedx = random(-1, 1);
26.     speedy = random(-1, 1);
27.     angle = random(TWO_PI);
28.     direction = new PVector(cos(angle), sin(angle));
29.     velocity = new PVector(direction.x*speedx, direction.y*speedy);
30.     // lifespan = int(random(1000));
31.     isAlive = true;
32.     inCollision = false;
33.     println("Hey you initialized a point!");
34.     println("Velocity : " + velocity);
35.     println("Location : " + location);
36.   }
37. 
    
38. 
    
39.   void burst(Gif animation) {
40.     image(animation, location.x-animation.width/2, location.y-animation.height/2);
41.     isAlive = false;
42.   }
43. 
    
44.   void burst(Movie animation) {
45. //    movieEvent(animation);
46.     image(animation, location.x-animation.width/2, location.y-animation.height/2, 50, 50);
47.     isAlive = false;
48.   }
49.   
50. //  void movieEvent(Movie m){
51. //    if(m.available()){
52. //      m.read();
53. //    }
54. //  }
55.     
56. 
    
57. 
    
58. 
    
59.   void display() {
60.     stroke(255);
61.     fill(0, 0, 255);
62.     ellipse(location.x, location.y, 6, 6);
63.   }
64. 
    
65.   void ckPos() {
66.     if (location.x < 0) {
67.       location.x = width;
68.     }
69.     else if (location.y < 0) {
70.       location.y = height;
71.     }
72.     else if(location.x > width){
73.       location.x = 0;
74.     }
75.     else if(location.y > height){
76.       location.y = 0;
77.     }
78.   }
79. 
    
80. 
    
81.   void update() {
82.     location.add(velocity);
83.     ckPos();
84.     display();
85.   }
86. }

Here is the "PointSystem" class, which choreographs the simulation : 

3. import java.util.Iterator;
4. import java.lang.Math.*;
5. import gifAnimation.*;
6. import processing.video.*;
7. import java.util.concurrent.*;
8. 
   
9. class PointSystem {
10. 
    
11.   int n;
12.   ArrayList<Point> points;
13.   Gif gifAnimation;
14.   Movie movAnimation;
15.   ExecutorService exec = Executors.newCachedThreadPool();
16. 
    
17. 
    
18.   PointSystem(int n, Gif animation) {
19.     points = new ArrayList<Point>();
20.     for (int i=0;i<n;i++) {
21.       points.add(new Point());
22.     }
23.     gifAnimation = animation;
24.     println("The length of the ArrayList is : " + points.size());
25.   }
26. 
    
27.   PointSystem(int n, Movie animation) {
28.     points = new ArrayList<Point>();
29.     for (int i=0;i<n;i++) {
30.       points.add(new Point());
31.     }
32.     movAnimation = animation;
33.     println("The length of the ArrayList is : " + points.size());
34.   }
35. 
    
36.   PVector[] ckCollisions(double thresh) {
37.     //check distances using a double for loop, skip if already found to be in collision
38.     PVector[] outArray = {
39.     };
40.     for (int i = 0; i < points.size(); i++) {
41.       Point point1 = points.get(i);
42.       if (point1.inCollision) {
43.         continue;
44.       }
45.       for (int j = 0; j < points.size(); j++) {
46.         if (i==j) {
47.           continue;
48.         }
49.         Point point2 = points.get(j);
50.         if (point2.inCollision) {
51.           continue;
52.         }
53.         double dist = pointEUDist(point1, point2);
54.         if (dist < thresh) {
55.           point1.inCollision = true;
56.           point1.isAlive = false;
57.           point2.inCollision = true;
58.           point2.isAlive = false;
59.           float[] xarr = {
60.             point1.location.x, point2.location.x
61.           };
62.           float[] yarr = {
63.             point1.location.y, point2.location.y
64.           }; 
65.           float xpos = mean(xarr);
66.           float ypos = mean(yarr);
67.           PVector curVec = new PVector(xpos, ypos);
68.           outArray = (PVector[]) append(outArray, curVec);
69.         }
70.       }
71.     }
72.     return(outArray);
73.   }
74. 
    
75.   float mean(float[] nums) {
76.     float runningTotal = 0;
77.     for (int i=0; i<nums.length; i++) {
78.       runningTotal += nums[i];
79.     }
80.     return (runningTotal/nums.length);
81.   }
82. 
    
83.   void burst(Point p1, Point p2) {
84.     float x = (p1.location.x+p2.location.x)/2;
85.     float y = (p1.location.y+p2.location.y)/2;
86.     if (gifAnimation!=null) {
87.       image(gifAnimation, x-10/2, y-10/2, 10, 10);
88.     }
89.     else if (movAnimation!=null) {
90.     }
91.     p1.isAlive = false;
92.     p2.isAlive = false;
93.   }
94. 
    
95.   double pointEUDist(Point p1, Point p2) {
96.     double dist = Math.sqrt( Math.pow((p1.location.x-p2.location.x), 2) + Math.pow((p1.location.y-p2.location.y), 2) );
97.     return dist;
98.   }
99. 
    
100.   void movieEvent(Movie m) {
101.     if (m.available()) {
102.       m.read();
103.     }
104.   }
105. 
     
106. 
     
107. 
     
108.   void run() {
109.     PVector[] expLocations = ckCollisions(10);
110.     if (expLocations.length > 0) {
111.       for (int i=0; i<expLocations.length; i++) {
112.         exec.execute(new Explosion(movAnimation, expLocations[i].x, expLocations[i].y, 100, 100));
113.       }
114.     }
115.     Iterator<Point> it = points.iterator();
116.     while (it.hasNext ()) {
117.       Point p = it.next();
118.       if (p.isAlive==false) {
119.         it.remove();
120.       }
121.       else {
122.         p.update();
123.       }
124.     }
125.   }
126. }

Here is the "Explosion" class. Since I couldn't get the explosions to display properly using standard serial execution, I implemented this class as an extension of the "Thread" class with a Runnable implementation. However the concurrent programming doesn't solve my problem, nor does it seem to effect the way the program was running before. : 

2. import processing.video.*;
3. import java.util.concurrent.*;
4. 
   
5. class Explosion extends Thread implements Runnable {
6.   
7.   Movie animation;
8.   float x;
9.   float y;
10.   float h;
11.   float w;
12.   boolean running;
13.   
14.   Explosion(Movie animation_,float x_, float y_, float w_, float h_){
15.     animation = animation_;
16.     x = x_;
17.     y = y_;
18.     w = w_;
19.     h = h_;
20.   }
21.   
22.   void start(){
23.     running = true;
24.     println("Animating an explosion");
25.   }
26.   
27.   void run(){
28.     image(animation, x - w/2, y - h/2, w, h);
29.     println("Exploding at : " + x + " " + y);
30.   }
31.   
32.   void movieEvent(){
33.     animation.read();
34.   }
35.   
36. }

This is my first processing project (and first java project), so please bear with me if I'm making some really noob mistakes here.

Basically, the program I wrote sends circles flying around and if they collide with each other, they "explode". For the explosion I've tried to use a .mp4 file as a Movie object and a .gif  file as a Gif object, but both seem to just play the first frame of the movie/gif (if that). If I just play the movie/gif using the image function in draw() the playback is fine.

My main question is, if I'm trying to display a movie/gif but the function call to display the movie is buried in a few layers of code what can I do to correctly play the movie when the two particles collide with each other?

Here is my code:

2. import gifAnimation.*;
3. import processing.video.*;
4. PointSystem ps;
5. String gifFileName = "explosion_animated_gif.gif";
6. String movFileName = "explosion.mp4";
7. Movie explosion;
8. Gif gifExp;
9. 
   
10. 
    
11. void setup(){
12.   size(500,500, P2D);
13.   frameRate(100);
14.   explosion = new Movie(this, movFileName);
15.   explosion.noLoop();
16.   explosion.speed(3);
17.   explosion.play();
18.   explosion.read();
19.   gifExp = new Gif(this, gifFileName);
20.   gifExp.loop();
21.   gifExp.play();
22.   ps = new PointSystem(10, gifExp);
23.   background(0);
24. }
25. 
    
26. void draw(){
27.   background(0);
28.   //image(gifExp, width/2 - gifExp.width/2, height/2 - gifExp.height/2);
29. // // image(explosion, width - explosion.width/2, height - explosion.height/2);
30. ps.run();
31. //image(explosion, mouseX - 100 - 25, mouseY-25,50,50);
32. //image(explosion, mouseX + 100 - 25, mouseY-25,50,50);
33. println(frameRate);
34. }

Here is the "Point" class, the objects that are flying around the screen:

2. import java.util.Iterator;
3. import processing.video.*;
4. 
   
5. 
   
6. class Point {
7. 
   
8.   PVector velocity;
9.   PVector gravity = new PVector(0, 0.01);
10.   float speedx;
11.   float speedy;
12.   PVector direction;
13.   PVector location;
14.   float xpos;
15.   float ypos;
16.   float angle;
17.   //  int lifespan;
18.   PShape p;
19.   boolean isAlive;
20.   boolean inCollision;
21. 
    
22.   Point() {
23.     xpos = random(width);
24.     ypos = random(height);
25.     location = new PVector(xpos, ypos);
26.     speedx = random(-1, 1);
27.     speedy = random(-1, 1);
28.     angle = random(TWO_PI);
29.     direction = new PVector(cos(angle), sin(angle));
30.     velocity = new PVector(direction.x*speedx, direction.y*speedy);
31.     // lifespan = int(random(1000));
32.     isAlive = true;
33.     inCollision = false;
34.     println("Hey you initialized a point!");
35.     println("Velocity : " + velocity);
36.     println("Location : " + location);
37.   }
38. 
    
39. 
    
40.   void burst(Gif animation) {
41.     image(animation, location.x-animation.width/2, location.y-animation.height/2);
42.     isAlive = false;
43.   }
44. 
    
45.   void burst(Movie animation) {
46. //    movieEvent(animation);
47.     image(animation, location.x-animation.width/2, location.y-animation.height/2, 50, 50);
48.     isAlive = false;
49.   }
50.   
51. //  void movieEvent(Movie m){
52. //    if(m.available()){
53. //      m.read();
54. //    }
55. //  }
56.     
57. 
    
58. 
    
59. 
    
60.   void display() {
61.     stroke(255);
62.     fill(0, 0, 255);
63.     ellipse(location.x, location.y, 6, 6);
64.   }
65. 
    
66.   void ckPos() {
67.     if (location.x < 0) {
68.       location.x = width;
69.     }
70.     else if (location.y < 0) {
71.       location.y = height;
72.     }
73.     else if(location.x > width){
74.       location.x = 0;
75.     }
76.     else if(location.y > height){
77.       location.y = 0;
78.     }
79.   }
80. 
    
81. 
    
82.   void update() {
83.     //velocity.add(gravity);
84.     location.add(velocity);
85.     ckPos();
86.     display();
87.     // lifespan--;
88.     //    if (lifespan < 0) {
89.     //      isAlive = false;
90.     //    }
91.   }
92. }

And here is the "PointSystem" class that choreographs the whole thing:

2. import java.util.Iterator;
3. import java.lang.Math.*;
4. import gifAnimation.*;
5. import processing.video.*;
6. class PointSystem {
7. 
   
8.   int n;
9.   ArrayList<Point> points;
10.   Gif gifAnimation;
11.   Movie movAnimation;
12. 
    
13.   PointSystem(int n, Gif animation) {
14.     points = new ArrayList<Point>();
15.     for (int i=0;i<n;i++) {
16.       points.add(new Point());
17.     }
18.     gifAnimation = animation;
19.     println("The length of the ArrayList is : " + points.size());
20.   }
21.   
22.   PointSystem(int n, Movie animation) {
23.     points = new ArrayList<Point>();
24.     for (int i=0;i<n;i++) {
25.       points.add(new Point());
26.     }
27.     movAnimation = animation;
28.     println("The length of the ArrayList is : " + points.size());
29.   }
30. 
    
31.   void ckCollisions(double thresh) {
32.     //check distances using a double for loop, skip if already found to be in collision
33.     for (int i = 0; i < points.size(); i++) {
34.       Point point1 = points.get(i);
35.       if (point1.inCollision) {
36.         continue;
37.       }
38.       for (int j = 0; j < points.size(); j++) {
39.         if (i==j) {
40.           continue;
41.         }
42.         Point point2 = points.get(j);
43.         if (point2.inCollision) {
44.           continue;
45.         }
46.         double dist = pointEUDist(point1, point2);
47.         if (dist < thresh) {
48.           point1.inCollision = true;
49.           point2.inCollision = true;
50.           burst(point1, point2);
51.         }
52.       }
53.     }
54.   }
55.   
56.   void burst(Point p1, Point p2){
57.     float x = (p1.location.x+p2.location.x)/2;
58.     float y = (p1.location.y+p2.location.y)/2;
59.     if(gifAnimation!=null){
60.       image(gifAnimation, x-gifAnimation.width/2, y-gifAnimation.height/2, 100, 100);
61.     }
62.     else if(movAnimation!=null){
63.       image(movAnimation, x-100/2, y-100/2, 100, 100);
64.     }
65.     p1.isAlive = false;
66.     p2.isAlive = false;
67.   }
68. 
    
69.   double pointEUDist(Point p1, Point p2) {
70.     double dist = Math.sqrt( Math.pow((p1.location.x-p2.location.x), 2) + Math.pow((p1.location.y-p2.location.y), 2) );
71.     return dist;
72.   }
73.   
74.   void movieEvent(Movie m){
75.     if(m.available()){
76.       m.read();
77.     }
78.   }
79. 
    
80. 
    
81. 
    
82.   void run() {
83.     ckCollisions(10);
84.     Iterator<Point> it = points.iterator();
85.     while (it.hasNext ()) {
86.       Point p = it.next();
87. //      if (p.inCollision) {
88. //        if(gifAnimation != null){
89. //          p.burst(gifAnimation);
90. //        }
91. //        else if(movAnimation != null){
92. //          movieEvent(movAnimation);
93. //          p.burst(movAnimation);
94. //        }
95. //      }
96.       if (p.isAlive==false) {
97.         it.remove();
98.       }
99.       else {
100.         p.update();
101.       }
102.     }
103.   }
104. }
105. 
     

Also I know the double for loop in the ckCollisions function is not the best way to do that but the system is small enough that performance hasn't been an issue with it.