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. }