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.