https://forum.processing.org/topic/avoiding-walls-instead-of-bouncing

The boids successfully avoid the walls thanks to lines 92 - 96, which change the angle of the boids path so that they turn back towards the circle's center. However, when they are at the rightmost side of the circle (at 0 degrees / 2pi), the boids appear to turn to avoid the wall and hit another one instantly, which causes them to keep moving outside of the boundary in a serpentine motion. So, once it's out, it constantly meets the condition to turn, which ends up making it unable to change directions. 

Could I check the angle of 'ang,' and if it is at 0 / 2pi, give different values to 'wander_theta'? The angle adjustment works for all other parts of the circle but that one side, so I think the angle would be significant. How should I start to solve this problem?

2. Cluster cluster;
3. Stage stage;
4. //PImage planarian;
5. 
   
6. void setup() {
7.   size(600,600);
8.   cluster = new Cluster(); //Initialize the arrayList that contains all the moving objects
9.   stage = new Stage(width/2,height/2,250); //Draws a circular stage that contains the moving objects
10.   for (int i = 0; i < 20; i++) {
11.     cluster.addFworm(new Fworm(new PVector(width/2,height/2), 2.0f)); //Adds a new object to the arrayList (first boid 
12.     //to the flock)
13.   }
14.   //planarian = loadImage("testW.png");
15. }
16. 
    
17. void draw() {
18.   background(220);
19.   stage.display();
20.   cluster.run(); //animates every object in the ArrayList
21. }
22. 
    
23. class Stage {
24.   float x;
25.   float y;
26.   float r;
27.   
28.   Stage(float x_, float y_, float r_){
29.     x = x_;
30.     y = y_;
31.     r = r_;
32.   }
33.   
34.   void display() {
35.     fill(240);
36.     noStroke();
37.     ellipse(x, y, r*2, r*2);
38.   }
39. }
40. 
    
41. class Cluster { //the 'flock' class from boids. 
42.   ArrayList fworms; // contains all objects
43.   
44.   Cluster() {
45.     fworms = new ArrayList();
46.   }
47.   
48.   void run() {
49.     for (int i = 0; i < fworms.size(); i++) {
50.       Fworm f = (Fworm) fworms.get(i);
51.       f.run(fworms); //animates each individual object
52.     }
53.   }
54.   
55.   void addFworm(Fworm f) { //the add object function
56.     fworms.add(f);
57.   }
58. }
59. 
    
60. class Fworm {
61. 
    
62.   PVector loc; 
63.   PVector vel;
64.   float max_wander_offset; //upper and lower ends of the range that generates a random number for changing 
65.   float wander_theta; //the randomized value assigned to the velocity
66.   float wander_offset;
67.   float maxspeed; //prevents the velocity from steadily increasing
68.   float r;
69.   
70.   Fworm(PVector l, float ms) {
71.     loc = l.get();
72.     max_wander_offset = 0.1;
73.     wander_theta = random(TWO_PI);
74.     vel = new PVector();
75.     maxspeed = ms;
76.     r = 6.0;
77.   }
78.   
79.   void run(ArrayList fworms) {
80.     update();
81.    // borders(); <-- the now obsolete border checking function from Flocking
82.     render();
83.   }
84.   
85.   void update() {
86.     wander_offset = random(-max_wander_offset, max_wander_offset);
87.     wander_theta += wander_offset;
88.     vel.x += cos(wander_theta);
89.     vel.y += sin(wander_theta);
90.     vel.limit(maxspeed);
91.     
92.     if (dist(stage.x, stage.y, loc.x, loc.y) > 210) {
93.       // Determine angle back to center of screen
94.       float ang = atan2(height/2-loc.y,width/2-loc.x);
95.       // adjust direction a bit in that direction...
96.        wander_theta += (ang-wander_theta)/20;
97.     }
98.     loc.add(vel);
99.   }
100.   
101.   void render() {
102.     
103.     float direction = vel.heading2D() + PI/2;
104.     fill(0); // the fill and stroke is only for the 
105.     stroke(255); // temporary placeholder triangle
106.     pushMatrix();
107.     translate(loc.x,loc.y);
108.     rotate(direction);
109.     //image(planarian, 0, 0);
110.     beginShape(TRIANGLES); //I'm using the image above, but the triangles are just so anybody could test this
111.     vertex(0, -r*2); 
112.     vertex(-r, r*2);
113.     vertex(r, r*2);
114.     endShape();
115.     popMatrix();
116.   }
117. 
     
118.   
119. }