Hey,

you are right, calling setup() is the wrong way. You should not call it at all. What you could do is just put the code that creates the circles into an own function (like createCircles() for example). Then call the function in setup() and when the mouse is pressed, call it again.
But in your case this would not work, because it would overwrite the circles array, so the previous circles would be deleted.
I think the best solution would be to create an ArrayList instead of an array and add the circles inside of your new function.

1. ArrayList<Circle> circles;
   int numCircles = 13; //number of circles
   int maxDistance;  //max distance between circles when draw lines
   int minDistance;
   int m;
   
   float bgX;
   float bgY;
   
   
   
   PImage bg;
   
   void setup() {
     size(500, 500);  //size of window
     smooth();  //draw circles with anti-aliased edge
     m = millis();
    
     bgX = width/2;
     bgY = width/2;
    
    
     //bg = loadImage("bg_trans.png");
   
     // create an arraylist
     circles = new ArrayList<Circle>();
     createCircles();
   }
   
   void draw() {
     // clear background
     background(0, 0, 25);
     tint(255, 50);
     //image(bg, bgX, bgY);
   
    
     // update and display the circles
     for (int i=0; i< circles.size(); i++) {
       circles.get(i).update();
       circles.get(i).display();
     }
   
     // define maximum distance
     maxDistance = 300;
     //minDistance = 50;
    
     //maxDistance = mouseX;  //manuplate lines by mouse cursor
    
     // look of the lines
     stroke(255, 130);
     strokeWeight(0.5);
   
     for (int i=0; i< circles.size(); i++) {
       // compare circle to other circles
       for (int j=i+1; j< circles.size(); j++) {
         // draw line if distance is below 'maxDistance'
         if (dist(circles.get(i).x, circles.get(i).y, circles.get(j).x, circles.get(j).y) < maxDistance){
           line(circles.get(i).x, circles.get(i).y, circles.get(j).x, circles.get(j).y);
         }
       }
     }
   }
   
   
   void mousePressed() {
     createCircles();
   }
   
   void createCircles(){
     for (int i=0; i< numCircles; i++) {
       circles.add(new Circle(random(0, width), random(0, height), random(2, 10), random(150, 255)));
     }
   }
   
   class Circle {
     float x, y, dia, opa;
    
     float speed=0;
     float gravity=0.1;
    
     float fallLimit = height;  //limit y for falling stars
    
    
     Circle(float x, float y, float dia, float opa) {
       this.x =x;
       this.y =y;
       this.dia = dia;
       this.opa = opa;
     }
    
    
   //circles move slightly in their position
     void update() {
       // code for movement here
       // this is just some random displacement
       x = x + random(-0.2, 0.2);
       y = y + random(-0.2, 0.2);
      
       int m = millis();
   
       speed = speed + gravity;
      
       if(y < fallLimit){
         y = y + speed;
       }
       if (y > fallLimit) {
         y = fallLimit;
       }
     }
   
   
    
     void display() {
       // code for drawing the circles
       noStroke();
       fill(255, opa);
       ellipse(x, y, dia, dia);
     }
   }

I changed some lines, positions etc. but it should show the concept.

I was too late    



hello,

in general it's not recommended to call setup().

Instead, take the stuff you need out of setup() into an own function initProgram() or so.

This you call from setup() and from mousepressed().

Here, please use arrayList instead of array; here you can easily append new circles.

Greetings, Chrisir

@sunooz, I answer to your comment above (no easy way to comment on a comment, Zoho doesn't allow it).

If you want to separate new and old circles, you need to have two array lists.
The first one will hold the old circles and will grow progressively (unless you eliminate the oldest ones).
The second one will take the new circles.
Once a circle becomes old (I don't know your criterion, can be a counter of draw calls), it can be moved to the list of old circles.
You can grow the latter indefinitely or scan it for really old circles, or just eliminate the firsts of the list, to maintain a constant maximum length.

" Someones said that processing is easy tool to use, but to me, it's really difficult"
Well, Processing, the tool, has nothing to do with the difficulty here... I shown no code above, it is only matter of logic, and knowing where to go. The same reasoning can be used, whatever the programming language you use. After that, that's mostly a matter of syntax...
It is mostly matter of experience: at first, we don't know where to go, how to do a task. By solving problems, by looking how other people solved problems, the general idea on how to attack a task becomes more natural.
It is a set of mind to acquire...
Some people just hate this, others (like me and most of those helping a lot here) just see that as a mind game, logical problems to solve, puzzles to assemble...

" I hate asking everything and giving all my problems to others"
Good attitude (other people just ask here to solve their problems...), but you shouldn't be afraid to ask for help, we like to help.

About array lists, see the JavaDoc: ArrayList
You will find all the stuff you can do with them.
I made a quick little sketch to illustrate how to pass values between two lists.

1. ArrayList<String> oldList = new ArrayList<String>();
2. ArrayList<String> newList = new ArrayList<String>();
3.  
4. void setup()
5. {
6.   size(200, 300);
7.   smooth();
8.  
9.   for (int i = 0; i < 10; i++)
10.   {
11.     newList.add("S " + i);
12.   }
13. }
14.  
15. void draw()
16. {
17.   background(255);
18.  
19.   fill(#8855AA);
20.   for (int i = 0; i < newList.size(); i++)
21.   {
22.     text(newList.get(i), 10, 20 + 12 * i);
23.   }
24.  
25.   fill(#55AA88);
26.   for (int i = 0; i < oldList.size(); i++)
27.   {
28.     text(oldList.get(i), 50, 20 + 12 * i);
29.   }
30. }
31.  
32. void keyPressed()
33. {
34.   // Get and remove
35.   String s = newList.remove(0);
36.   oldList.add(s);
37.   newList.add(key + " " + frameCount);
38. }

I hope it will give you an idea how it (can) work.