Another attempt with Flow Field, but I'm not satisfied yet with smoothness...

1. boolean run = true;
2. int flowCells = 5; // how many rows and colums
3. float[] [] directions = new float[flowCells][flowCells]; // create 2d array
4. int numBalls = 1;
5. Ball[] b = new Ball [numBalls];
6. float noiseStep = .095;
7. float noiseOffset = 0.0;
8. 
   
9. void setup() {
10.   size(800, 800);
11.   smooth();
12.   frameRate(30);
13.   background(0);
14.   noStroke();
15.   fill(255, 30); 
16.   for (int i = 0; i < numBalls; i++) {
17.     b[i] = new Ball();
18.   }
19. }
20. 
    
21. void draw() {
22.   if (run == true) {
23.     //background(0);
24.     // construct flow field
25.     for (int x = 0; x < flowCells; x++) {
26.       for (int y = 0; y < flowCells; y++) {
27.         directions[x] [y] = noise((x*noiseStep)+noiseOffset, (y*noiseStep)+noiseOffset)* (TWO_PI*2);
28.       }
29.     }
30.     for (int i = 0; i < numBalls; i++) {
31.       b[i].display();
32.     }
33.     noiseOffset += 0.01;
34.   }
35. }
36. 
    
37. class Ball {
38.   float x;
39.   float y;
40.   float mass = 5.0;
41.   Ball() {
42.     x = width/2.;
43.     y = height/2.;
44.   }
45. 
    
46.   void display() {
47.     float move = directions [int(x / (width/flowCells))] [int(y / (height/flowCells))];
48.     float speed = (((mass - 2.) *-1.) + 40.1)*0.09;
49.     x += speed * cos (move);
50.     y += speed * sin (move);   
51.     pushMatrix();
52.     translate(x, y);
53.     popMatrix();
54.     fill(255, 0, 0);
55.     noStroke();
56.     ellipse(x, y, 5, 5);
57.    
58.     //send ball back to center if it goes off edge
59.     if (x <= 0 || x >= width || y <=0 || y >= height) {
60.       background(0);
61.       x = (width/2);
62.       y = (height/2);
63.     }
64.   }
65. }

I suppose that there must be something in angle between two vectors..

Is there an easy way to smooth out the transition between waypoints?

1. int STEPS = 100;
2. int currentStep = 0;
3. PVector p1, p2;
4. PVector lastDirection, nextDirection;
5. float angle;
6. PVector nextCenter() {
7.   return new PVector(random(width), random(height));
8. }
9. PVector randomDirection() {
10.   PVector v = new PVector(random(1), random(1));
11.   v.normalize();
12.   return v;
13. }
14. 
    
15. void setup() {
16.   size(1280, 720);
17.   frameRate(30);
18.   smooth();
19.   background(0);
20.   p1 = new PVector(height/2, width/2);
21.   p2 = nextCenter();
22.   lastDirection = randomDirection();
23.   nextDirection = randomDirection();
24. }
25. 
    
26. void draw() {
27.   smooth();
28.   noStroke();
29.   float t = (float)currentStep / (float)STEPS;
30.   float x = bezierPoint(p1.x, 200*lastDirection.x + p1.x, 200*nextDirection.x + p2.x, p2.x, t);
31.   float y = bezierPoint(p1.y, 200*lastDirection.y + p1.y, 200*nextDirection.y + p2.y, p2.y, t);
32.   currentStep ++;
33.   if (currentStep >= STEPS) {
34.     currentStep = 0;
35.     lastDirection = PVector.mult(nextDirection, -1);
36.     nextDirection = randomDirection();
37.     p1 = p2;
38.     p2 = nextCenter();
39.     angle = PVector.angleBetween(p1, p2);
40.     println(angle*180/PI);
41.     fill(random(255), random(255), random(255));
42.   }
43.  
44.   ellipse(x, y, 5, 5);
45.  
46. }

Solution with keyframes:
code from https://forum.processing.org/topic/code-for-smooth-spline-animation-with-keyframes

TODO: have a constant speed over the curve

1. PFont font;
2. int L = 10; // amount of keyframes
3. Keyframe[] frame = new Keyframe[L];
4. int F = 0;
5. float xx, yy;
6. float[] xxx = new float[L];
7. float[] yyy = new float[L];
8. 
   
9. void setup() {
10.   size(1280, 720);
11.   background(255);
12.   smooth();
13.   font = loadFont("ArialMT-18.vlw");
14.   textFont(font);
15.   xx = random(50, width-50);
16.   yy = random(50, height-50);
17.   xxx[0] = xx;
18.   yyy[0] = yy;
19.   for (int i=1; i<L; i++) {
20.     do {
21.       xx = random(50, width-50);
22.       yy = random(50, height-50);
23.     }
24.     while ( dist (xx, yy, xxx[i-1], yyy[i-1] ) < 400.0);
25.     xxx[i] = xx;
26.     yyy[i] = yy;
27.   }
28.   // Create random keyframes
29.   for (int i=0; i<L; i++) {
30.     frame[i] = new Keyframe(xxx[i], yyy[i], i == 0 ? 0 : frame[i-1].frame + 200);
31.   }
32. }
33. 
    
34. void draw() {
35.   background(0);
36.   smooth();
37.   //frame[1].pos.x = mouseX;
38.   //frame[1].pos.y = mouseY;
39.   // Draw keyframe locations
40.   for (int i=0; i<L; i++) {
41.     noStroke();
42.     fill(0, 0, 255);
43.     ellipse(frame[i].pos.x, frame[i].pos.y, 10, 10);
44.     fill(255, 255, 0);
45.     textSize(13);
46.     text(i+1, frame[i].pos.x + 20, frame[i].pos.y);
47.   } 
48.   PVector now = getPos(F);
49.   fill(255, 0, 0);
50.   ellipse(now.x, now.y, 20, 20);
51.   F++;
52. }
53. 
    
54. PVector getPos(int t) {
55.   // If time is 0 or less, return the initial position
56.   if (t < 1) {
57.     return frame[0].pos;
58.   } 
59.   // If time is past the last keyframe, return last position
60.   if (t >= frame[L-1].frame) {
61.     return frame[L-1].pos;
62.   }
63.   int segment = getCurrentSegment(t);
64.   float time = getTimeInCurrentSegment(t, segment);
65.   // Bezier tweening start
66.   // Calculate the first control point for the bezier curve
67.   PVector control0, control1;
68.   float angFrom, angTo, ang, dx=0, dy=0, segmentLength;
69.   // Calculate the first control point for the bezier curve
70.   if (segment > 0) {
71.     angFrom = atan2(frame[segment+1].pos.y - frame[segment].pos.y, frame[segment+1].pos.x - frame[segment].pos.x);
72.     angTo = atan2(frame[segment].pos.y - frame[segment-1].pos.y, frame[segment].pos.x - frame[segment-1].pos.x);
73.     fill(0, 255, 0);
74.     ellipse(frame[segment].pos.x, frame[segment].pos.y, 15, 15);
75.     float denscoef = 0.7;
76.     segmentLength = denscoef * PVector.dist(frame[segment].pos, frame[segment+1].pos) / 2;
77.     ang = getTangent(angFrom, angTo);
78.     dx = segmentLength * cos(ang);
79.     dy = segmentLength * sin(ang);
80.   }
81.   control0 = new PVector(frame[segment].pos.x + dx, frame[segment].pos.y + dy);
82.   // Calculate the second control point for the bezier curve
83.   dx = 0;
84.   dy = 0;
85.   if (segment < L-2) {
86.     angFrom = atan2(frame[segment].pos.y - frame[segment+1].pos.y, frame[segment].pos.x - frame[segment+1].pos.x);
87.     angTo = atan2(frame[segment+1].pos.y - frame[segment+2].pos.y, frame[segment+1].pos.x - frame[segment+2].pos.x);
88.     float denscoef = 0.7;
89.     segmentLength = denscoef * PVector.dist(frame[segment].pos, frame[segment+1].pos) / 2;
90.     ang = getTangent(angFrom, angTo);
91.     dx = segmentLength * cos(ang);
92.     dy = segmentLength * sin(ang);
93.   }
94.   control1 = new PVector(frame[segment+1].pos.x + dx, frame[segment+1].pos.y + dy);
95.   // Calculate the position of the current point using bezier
96.   float newx = bezierPoint(frame[segment].pos.x, control0.x, control1.x, frame[segment+1].pos.x, time);
97.   float newy = bezierPoint(frame[segment].pos.y, control0.y, control1.y, frame[segment+1].pos.y, time);
98.   // bezier end
99.   return new PVector(newx, newy);
100. }
101. 
     
102. float getTangent(float fromAngle, float toAngle) {
103.   if (fromAngle < 0) {
104.     fromAngle += TWO_PI;
105.   }
106.   if (toAngle < 0) {
107.     toAngle += TWO_PI;
108.   }
109.   float ang = fromAngle + (toAngle - fromAngle) / 2;
110.   if (abs(fromAngle - toAngle) > PI) {
111.     ang -= PI;
112.   }
113.   return ang;
114. }
115. 
     
116. float getTimeInCurrentSegment(int t, int segment) {
117.   float segmentLength = frame[segment+1].frame - frame[segment].frame;
118.   float relativeIndex = t - frame[segment].frame;
119.   return relativeIndex / segmentLength;
120. }
121. 
     
122. int getCurrentSegment(int t) {
123.   int segment;
124.   for (segment=0; segment<L; segment++) {
125.     if (frame[segment].frame > t) {
126.       return segment - 1;
127.     }
128.   }
129.   return 0;
130. }
131. 
     
132. class Keyframe {
133.   PVector pos;
134.   int frame;
135.   Keyframe(float x, float y, int frame) {
136.     this.pos = new PVector(x, y);
137.     this.frame = frame;
138.   }
139. }