On the hardware side is a monitor display connected to a rotating mount. Attached to the back of the monitor is a rotary encoder. On the software side is maze processing sketch communicate with arduino which forward the data from rotary encoder to processing sketch.
Boundaries of the maze (full screen mode) would be actually the edges of the screen.

How to ensure that all vertices will be on the right place ? Make all graphics and physics in off-screen buffer and then translate, rotate and place screen buffer in default position ??

BTW, when rotation is faster, green ball penetrates blue fixed rectangle. Is there any way to avoid this?

1. import fisica.*;
2. public FWorld world;
3. public Board board;
4. public MazeNode[][] nodes;
5. public ArrayList<FBody> rotateUs;
6. public FBody body2;
7. public float mazeAng;
8. public float mouseAng;
9. public int offsetX = 0;
10. public int offsetY = 0;
11. public PFont font48;
12. public PFont font36;
13. public boolean gamePaused = false;
14. public boolean cursorLeftUnpauseCircle = true;
15. // constants
16. public static final int UI_BAR_HEIGHT = 40;
17. public static final float ROT_SPEED = 0.05;  // this can be turned up, because the ball is in rotateUs
18. public int ROWS = 1;
19. public int COLS = 1;
20. public int GAP = 500;
21. public int rows = ROWS;
22. public int cols = COLS;
23. public int gap = GAP;
24. void setup()
25. {
26.   size(800, 800);
27.   //size(640,640,P2D);  // causes walls to be invisible...?
28.   smooth();
29.   // physics stuff
30.   Fisica.init(this);
31.   world = new FWorld();
32.   //world.setGravity(0, 30);
33.   body2 = new FCircle(50);
34.   body2.setPosition(width/2, height/4);
35.   body2.setFill(50, 255, 50);
36.   body2.setStroke(0);
37.   body2.setStrokeWeight(3);
38.   body2.setRestitution(0);
39.   body2.setFriction(1);
40.  
41.   world.add(body2);
42.   reset();
43. }
44. public void reset()
45. {
46.   // stupid hack so changing maze settings in the UI doesn't frak up code (eg - orbiters) that use those settings
47.   ROWS = rows;
48.   COLS = cols;
49.   GAP = gap;
50.   // end stupid hack
51.   // offset values describe blank space between applet edges and the edges of the maze
52.   offsetX = (width - COLS*GAP)/2 + GAP/2;
53.   offsetY = (height - ROWS*GAP)/2 + GAP/2;
54.   mazeAng = 0.0;
55.   mouseAng = 0.0;
56.   cursorLeftUnpauseCircle = true;
57.   if (mag(mouseX - (width/2 + width/4 * cos(mazeAng)), mouseY - (height/2 - height/4 * sin(mazeAng))) > 50)
58.     gamePaused = true;
59.   else
60.     gamePaused = false;
61.   // declare and initialize field of maze nodes/tiles
62.   nodes = new MazeNode[ROWS][COLS];
63.   for (int x = 0; x < ROWS; ++x)
64.     for (int y = 0; y < COLS; ++y)
65.       nodes[x][y] = new MazeNode();
66.   world.clear();
67.   rotateUs = new ArrayList<FBody>();
68.   board = new Board(nodes);
69.   board.initTerrain();
70.  
71. }
72. void draw()
73. { 
74.   if (!focused)  // applet lost focus
75.     gamePaused = true;
76.   if (!gamePaused)
77.     background(255);
78.   else  // if game paused, shade out background and draw unpausing circle
79.   {
80.     background(180);
81.     stroke(0);
82.     fill(255);
83.     ellipse(width/2 + width/4 * cos(mazeAng), height/2 - height/4 * sin(mazeAng), 100, 100);
84.   }
85.  
86.   world.draw();
87.   if (!gamePaused)
88.   {
89.     // calculate angle and rotate maze
90.     float diffAng = mazeAng - mouseAng;
91.     // angle adjustments for crossing the 180-degree line
92.     if (abs(mazeAng - mouseAng + 2*PI) < abs(diffAng))
93.       diffAng = mazeAng - mouseAng + 2*PI;
94.     if (abs(mazeAng - mouseAng - 2*PI) < abs(diffAng))
95.       diffAng = mazeAng - mouseAng - 2*PI;
96.     board.rotateTerrain(ROT_SPEED*diffAng);
97.     // end of angle calculation and maze rotation
98.     // draw difference between maze angle and mouse angle
99.     float colorScale = abs(diffAng) * 255 / PI;
100.     fill(colorScale, 0, 255 - colorScale, 60);
101.     arc(width/2, height/2, width/2, height/2, -mazeAng, -mazeAng + diffAng);
102.     arc(width/2, height/2, width/2, height/2, -mazeAng + diffAng, -mazeAng);
103.     // end of draw difference between maze angle and mouse angle
104.     // fisica functions for drawing and simulating world physics
105.     world.step();
106.   }
107.   // UI bar must be drawn on top, so it's at the bottom
108.   noStroke();
109.   fill(0, 80);
110.   rect(0, 0, width, UI_BAR_HEIGHT);
111. }
112. void mouseMoved()
113. {
114.   // if mouse is over the UI bar, pause game
115.   if (mouseY < UI_BAR_HEIGHT)
116.     gamePaused = true;
117.   if (!gamePaused)  // if game isn't paused rotate maze as normal
118.     mouseAng = atan2(-(mouseY - height/2), mouseX - width/2);
119.   else  // if game is paused, don't unpause until mouse moves back into highlighted circle
120.   {
121.     if (cursorLeftUnpauseCircle && mag(mouseX - (width/2 + width/4 * cos(mazeAng)), mouseY - (height/2 - height/4 * sin(mazeAng))) < 50)
122.       gamePaused = false;
123.     else if (!cursorLeftUnpauseCircle && mag(mouseX - (width/2 + width/4 * cos(mazeAng)), mouseY - (height/2 - height/4 * sin(mazeAng))) > 50)
124.       cursorLeftUnpauseCircle = true;
125.   }
126. }
127. class Board
128. {
129.   /* terrain (walls) */
130.   private MazeNode nodes[][];
131.   public Board(MazeNode nodes[][])
132.   {
133.     this.nodes = nodes;
134.   }
135.   public void rotateTerrain(float rotAmt)
136.   {
137.     //mazeAng -= rotAmt;
138.     //mazeAng = mazeAng % (2*PI);
139.     // linear transformation with matrix T = [[cos, -sin],[sin, cos]]
140.     // Matrix Theory was a helpful class, yay!
141.     PVector transX = new PVector(cos(rotAmt), -sin(rotAmt));
142.     PVector transY = new PVector(sin(rotAmt), cos(rotAmt));
143.     for (FBody fb : rotateUs)
144.     {
145.       fb.adjustRotation(rotAmt);
146.       PVector v = new PVector(fb.getX() - width/2, fb.getY() - height/2);
147.       fb.setPosition(v.dot(transX) + width/2, v.dot(transY) + height/2);
148.     }
149.   }
150.   public void initTerrain()
151.   {
152.     int row, col;
153.     // fill in north and west walls for every node
154.     for (row = 0; row < ROWS; ++row)
155.     {
156.       for (col = 0; col < COLS; ++col)
157.       {
158.         if (nodes[row][col].walls[0] == 1)  // north wall exists
159.         {
160.           FBox fb = new FBox(GAP, 10);
161.           fb.setPosition(col * GAP + offsetX, row * GAP - (GAP/2) + offsetY);
162.           fb.setStatic(true);
163.           //fb.setGrabbable(false);    // <-- THIS COULD PROVIDE INTERESTING OPPORTUNITIES
164.           fb.setFill(0);
165.           rotateUs.add(fb);
166.           world.add(fb);
167.         }
168.         if (nodes[row][col].walls[3] == 1)  // west wall exists
169.         {
170.           FBox fb = new FBox(10, GAP);
171.           fb.setPosition(col * GAP - (GAP/2) + offsetX, row * GAP + offsetY);
172.           fb.setStatic(true);
173.           //fb.setGrabbable(false);    // <-- THIS COULD PROVIDE INTERESTING OPPORTUNITIES
174.           fb.setFill(0);
175.           rotateUs.add(fb);
176.           world.add(fb);
177.         }
178.       }
179.     }
180.     // fill in the east walls for the last column
181.     col = COLS - 1;
182.     for (row = 0; row < ROWS; ++row)
183.     {
184.       if (nodes[row][col].walls[1] == 1)  // east wall exists
185.       {
186.         FBox fb = new FBox(10, GAP);
187.         fb.setPosition(col * GAP + (GAP/2) + offsetX, row * GAP + offsetY);
188.         fb.setStatic(true);
189.         //fb.setGrabbable(false);    // <-- THIS COULD PROVIDE INTERESTING OPPORTUNITIES
190.         fb.setFill(0);
191.         rotateUs.add(fb);
192.         world.add(fb);
193.       }
194.     }
195.     // fill in the south walls for the last row
196.     row = ROWS - 1;
197.     for (col = 0; col < COLS; ++col)
198.     {
199.       if (nodes[row][col].walls[2] == 1)  // south wall exists
200.       {
201.         FBox fb = new FBox(GAP, 10);
202.         fb.setPosition(col * GAP + offsetX, row * GAP + (GAP/2) + offsetY);
203.         fb.setStatic(true);
204.         //fb.setGrabbable(false);    // <-- THIS COULD PROVIDE INTERESTING OPPORTUNITIES
205.         fb.setFill(0);
206.         rotateUs.add(fb);
207.         world.add(fb);
208.       }
209.     }
210.    
211.     FBody fb = new FBox(350, 15);
212.     fb.setPosition(width/2-70, height/2);
213.     fb.setStatic(true);
214.     fb.setFill(0, 50, 250);
215.     fb.setStroke(0);
216.     fb.setStrokeWeight(3);
217.     rotateUs.add(fb);
218.     world.add(fb);
219.    
220.   }
221. }
222. class MazeEdge
223. {
224.   public int row;
225.   public int col;
226.   public int dir;  // will be 0 (north) or 3 (west)
227.   public MazeEdge(int row, int col, int dir)
228.   {
229.     this.row = row;
230.     this.col = col;
231.     this.dir = dir;
232.   }
233. }
234. class MazeNode
235. {
236.   // [0] = north wall
237.   // [1] = east wall
238.   // [2] = south wall
239.   // [3] = west wall
240.   public int walls[] = {
241.     1, 1, 1, 1
242.   };
243.   public boolean visited;
244.   public MazeNode()
245.   {
246.     visited = false;
247.   }
248.   public String toString()
249.   {
250.     return "[" + walls[0] + " " + walls[1] + " " + walls[2] + " " + walls[3] + "]";
251.   }
252. }