do you know this

https://forum.processing.org/topic/particle-collision-within-a-circle

but amnons Code uses Vectors

https://forum.processing.org/topic/particle-collision-within-a-circle#25080000001418009

Gave it a shot. The code is a bit messy and not quite perfected (disclaimer! ), but hopefully it will give you some insight and serve as a starting point for further explorations. Perhaps I will try to do it with Toxiclibs next, because I think it will actually be shorter and easier using all the math magic in there.

Code Example

1. ArrayList <PVector> reflector = new ArrayList <PVector> ();
2. ArrayList <PVector> lines = new ArrayList <PVector> ();
3. PVector origin, target;
4.  
5. void setup() {
6.   size(500, 500);
7.   smooth();
8.   setLines();
9. }
10.  
11. void draw() {
12.   background(255);
13.   translate(width/2, height/2);
14.  
15.   setReflectorPoints(frameCount*0.5);
16.  
17.   origin = new PVector(0, 175);
18.   target = new PVector(0, -75);
19.  
20.   for (int i=1; i<reflector.size(); i++) {
21.     PVector p = reflector.get(i-1);
22.     PVector c = reflector.get(i);
23.     PVector pt = drawLine(p, c);
24.     if (pt != null) {
25.       PVector directionTarget = directionVector(target, origin);
26.       directionTarget.mult(pt.dist(origin));
27.      
28.       stroke(0, 0, 255);
29.       strokeWeight(2.5);
30.       pushMatrix();
31.       translate(origin.x, origin.y);
32.       line(0, 0, directionTarget.x, directionTarget.y);
33.       popMatrix();
34.      
35.       PVector directionLine = directionVector(p, c);
36.       PVector reflection = directionTarget.get();
37.       directionLine.mult(2*directionLine.dot(reflection));
38.       reflection.sub(directionLine);
39.       reflection.mult(-2);
40.      
41.       origin = pt.get();
42.       target = pt.get();
43.       target.add(reflection);
44.      
45.       line(origin.x, origin.y, target.x, target.y);
46.     }
47.   }
48.  
49.   for (int i=2; i<lines.size(); i+=2) {
50.     PVector p = lines.get(i-1);
51.     PVector c = lines.get(i);
52.     drawLine(p, c);
53.   }
54. }
55.  
56. void setLines() {
57.   int numpoints = 10;
58.   for (int i=0; i<numpoints+1; i++) {
59.     lines.add(new PVector(sin(radians(i*360/numpoints-10))*200, cos(radians(i*360/numpoints-10))*200));
60.     lines.add(new PVector(sin(radians(i*360/numpoints+10))*200, cos(radians(i*360/numpoints+10))*200));
61.   }
62. }
63.  
64. void setReflectorPoints(float rotation) {
65.   reflector.clear();
66.   int numpoints = 4;
67.   for (int i=0; i<numpoints+1; i++) {
68.     reflector.add(new PVector(sin(radians(i*360/numpoints-rotation))*50, cos(radians(i*360/numpoints-rotation))*50-75));
69.   }
70. }
71.  
72. PVector directionVector(PVector p1, PVector p2) {
73.   PVector pr = p1.get();
74.   pr.sub(p2);
75.   pr.normalize();
76.   return pr;
77. }
78.  
79. PVector drawLine(PVector p, PVector c) {
80.   PVector pt = findIntersection(p, c, origin, target);
81.   if (pt != null) {
82.     stroke(255, 0, 0);
83.     strokeWeight(5);
84.     line(p.x, p.y, c.x, c.y);
85.     noStroke();
86.     fill(0);
87.     ellipse(pt.x, pt.y, 10, 10);
88.   } else {
89.     stroke(0);
90.     strokeWeight(1);
91.     line(p.x, p.y, c.x, c.y);
92.   }
93.   return pt;
94. }
95.  
96. // line intersection code by Marius Watz
97. PVector findIntersection(PVector p1, PVector p2, PVector p3, PVector p4) {
98.   float xD1, yD1, xD2, yD2, xD3, yD3;
99.   float dot, deg, len1, len2;
100.   float segmentLen1, segmentLen2;
101.   float ua, ub, div;
102.  
103.   xD1=p2.x-p1.x;
104.   xD2=p4.x-p3.x;
105.   yD1=p2.y-p1.y;
106.   yD2=p4.y-p3.y;
107.   xD3=p1.x-p3.x;
108.   yD3=p1.y-p3.y;
109.  
110.   len1=sqrt(xD1*xD1+yD1*yD1);
111.   len2=sqrt(xD2*xD2+yD2*yD2);
112.  
113.   dot=(xD1*xD2+yD1*yD2);
114.   deg=dot/(len1*len2);
115.  
116.   if (abs(deg)==1) { return null; }
117.  
118.   PVector pt=new PVector(0, 0);
119.   div=yD2*xD1-xD2*yD1;
120.   ua=(xD2*yD3-yD2*xD3)/div;
121.   ub=(xD1*yD3-yD1*xD3)/div;
122.   pt.x=p1.x+ua*xD1;
123.   pt.y=p1.y+ua*yD1;
124.  
125.   xD1=pt.x-p1.x;
126.   xD2=pt.x-p2.x;
127.   yD1=pt.y-p1.y;
128.   yD2=pt.y-p2.y;
129.   segmentLen1=sqrt(xD1*xD1+yD1*yD1)+sqrt(xD2*xD2+yD2*yD2);
130.  
131.   xD1=pt.x-p3.x;
132.   xD2=pt.x-p4.x;
133.   yD1=pt.y-p3.y;
134.   yD2=pt.y-p4.y;
135.   segmentLen2=sqrt(xD1*xD1+yD1*yD1)+sqrt(xD2*xD2+yD2*yD2);
136.  
137.   if (abs(len1-segmentLen1)>0.01 || abs(len2-segmentLen2)>0.01) { return null; }
138.  
139.   return pt;
140. }

Thanks for everything!