It is hard to tell as we cannot run your code.
But when bouncing, you don't change the acc, so it might be a cause of your trouble.

Thanks, I'll start there. If things don't work out I'll post the rest of the code!

Thanks for the help! I have changed the acc and now the bouncing works on the left side but not the right.

Does anybody have an idea why is works on the left but not on the right? Here is all the code (using toxiclibs library):

import toxi.geom.*;


//DECLARE
ArrayList ballCollection;


void setup() {
  size (600, 600);
  smooth();

  //INITIALIZE
  ballCollection = new ArrayList();

  for (int i =0; i < 500; i++) {

    Vec3D origin = new Vec3D(100 , random(250, 600), 0);
    Ball myBall = new Ball(origin);
    ballCollection.add(myBall);
  }
}


void draw() {
  background(0);
 



  //CALL FUNCTIONALITY


     
 
  for (int i =0; i < ballCollection.size(); i++) {
    Ball mb = (Ball) ballCollection.get(i);
    mb.run();
  }
  }






class Ball {
  // GLOBAL VARIABLES
  Vec3D loc = new Vec3D (0, 0, 0);
  Vec3D speed = new Vec3D (0, 0, 0);

  Vec3D acc = new Vec3D (0, 0, 0);
  int speedyness = (int) random (2, 8);
  float tornadospeed;

  //CONSTRUCTOR
  Ball(Vec3D _loc) {

    loc = _loc;
  }


  //FUNCTIONS

  void run() {
    move();
    align();
    bounce();
    display();
  }




  void align() { 


    Ball other = (Ball) ballCollection.get((int) random(ballCollection.size()));


    if (other.loc.x > loc.x) {
      speed.x = random (-30, 135)+tornadospeed;
    }
    else {
      speed.x = random (-135, 30)+tornadospeed;
    }
    if (keyPressed) {
      if (key==CODED) {
        if (keyCode==LEFT) {
          tornadospeed = tornadospeed - 0.1;
        }
        if (keyCode==RIGHT) {
          tornadospeed = tornadospeed + 0.1;
        }
      }
    }
  }




  void bounce() {
    if (loc.x > width) {
      loc.x = speed.x * -1;
    }
    if (loc.x < 0) {
      loc.x = speed.x * -1;
    }
    if (loc.x < 0) {
      acc.x = acc.x * -1;
    }
    if (loc.x > width) {
      acc.x = acc.x * 1;
    }
    if (loc.y > height) {
      speed.y = speed.y * -1;
    }
    if (loc.y < 350) {
      speed.y = speed.y * -1;
    }
  }


  void move() {

    speed.addSelf(acc);

    speed.limit (speedyness);

    loc.addSelf(speed);

    acc.clear();
  }


  void display() {
    fill(255, 0, 0);
    ellipse(loc.x, loc.y, random (2, 8), random (2, 8));
  }
}

Multiplying a variable by 1 doesn't change much the state of the object...
You forgot the minus sign.
And you can put both the speed and the acc changes in the same test: it is shorter, easier to understand and more logical.

Hi,

Ah I must have overlooked forgetting the minus! I put a minus in front but it doesn't help. Any other ideas?

Try changing the bounce method to the code shown below (loc.x = speed * -1 makes no sense)

1. void bounce() {
2.     if (loc.x > width) {
3.       speed.x = speed.x * -1;
4.       acc.x = acc.x * -1;
5.     }
6.     if (loc.x < 0) {
7.       speed.x = speed.x * -1;
8.       acc.x = acc.x * -1;
9.     }
10.     if (loc.y > height) {
11.       speed.y = speed.y * -1;
12.     }
13.     if (loc.y < 350) {
14.       speed.y = speed.y * -1;
15.     }
16.   }

This still might not work perfectly.

If after you change the code you find the ball jiggling on the edges or even just disappearing then the problem is slightly more complex and I will try to describe it:-

When a ball moves the current speed is added to the current position to give a new position. If the new position is 'off-screen' then the speed and acceleration are reversed (by multiplying by -1). If when the ball is moved next it moves 'on-screen' then all is well; BUT if the ball is still 'off-screen' then the speed and acceleration is reversed again and the ball moves further 'off-screen' the chances of getting it back are remote.

Instead of simply multiplying by -1 try this code Reference for abs()

1. void bounce() {
2.     if (loc.x > width) {
3.       speed.x = abs(speed.x)  -1;
4.       acc.x = abs(acc.x) * -1;
5.     }
6.     if (loc.x < 0) {
7.       speed.x = abs(speed.x);
8.       acc.x = abs(acc.x);
9.     }
10.          // I have assume you want to keep the balls
11.         // between 350 and height
12.     if (loc.y > height) {
13.       speed.y = abs(speed.y) * -1;
14.     }
15.     if (loc.y < 350) {
16.       speed.y = abs(speed.y) ;
17.     }
18.   }

Hi,

Thanks for the help! The first one doesn't work properly. If the tornado gets to either one of the sides a lot of the balls  disappear.

The second version (with abs) works very well on the right side but again not on the left. The balls just keep on moving off the screen. Any other ideas perhaps. Again, thank you all for your time.

So the second version works but only on the right. I have looked at the code and can see no mistake, I have used this technique many times because if implemented correctly it workds in all circumstances.

I have worked on the assumption that both speed and acc should be positive to move right and both negative to move left. Also that a move comprises of two steps

1. speed = speed + acc
2. loc = loc + speed

If my assumptions are correct then I would check you have correctly translated the code into your program.

Hi,

I stated it works on the right, but I meant it works on the left (sorry). If the tornado moves to the right and reaches the edge it just goes on.

But I'll go and check everything again. If anything comes to mind, please let me know and thanks again for you time.

It works! Thanks people!