Need help with java program, the task is break up a floor plan into rooms that are no smaller than $3$ by $3$ using recursion.

Okay, so hear me out: I want to design layouts for the floor plans of buildings, but I also want to express my appreciation

for Piet Mondrian and neoplasticism! This means I need to divide up the floors of a building, but I won$$t be going for the

traditional $$hallways$$ and $$functional workplace$$ approaches $($because those are boring$).$

Let$$s look at a couple quick examples:

Here, you$$ll see that we$$ve broken the floors up into arbitrarily$-$separated rooms. As noted above there$$s no hallways, but

there$$s still the ability to travel from anywhere on the floor to anywhere else.

The principle is actually pretty simple:

$$ We treat the available space on a floor as effectively a grid of cells

$$ That grid may have arbitrary granularity $($hence the two examples above: same dimensions; different cell sizes$)$

$$ The grid does not include the walls; instead the walls are boundaries between spaces

$$ We start with initially one large room

$$ Any given room may be $$split up$$ into two rooms, with a door along the newly$-$added wall separating them

$$ Since it$$s recursive, those two rooms may themselves each be split up into two... you get the idea

$$ A $$wider$$ room will be split horizontally by a vertical wall, a $$taller$$ room will be split vertically by a horizontal

wall. Since there$$s no compelling reason to pick either for a $$square$$ room, we$$ll just say that also gets split

horizontally by a vertical wall

$$ We$$ll get to the $$cut$-$off$($stopping point$)$ a bit further down

Let$$s walk through a couple of the first steps to start one:

Here, we$$ve decided to divide our space into $16\backslash$times $16$ spaces. As it$$s a square, we$$ll favour a vertical line. We have $15$

possible positions for a wall $($between any two cells$).$ Just for ha$-$ha$$s$,$ let$$s start with the middle?

Here you can see we$$ve added the door $($depicted as a $$gap$$ for now$)$ roughly $$ of the way up$.$

We would then recurse onto both of these rooms.

The left room is $$taller$,$ so we split it vertically with a horizontal wall:

$($The colours and letters are just for easier reference$)$

Notice that:

$$ The doors may be placed anywhere along the wall, so long as they$$re within the $$grid$$ boundaries, and always $$one

space$$

$$ Though we can further and further subdivide A$/$B$,$ we$$ll eventually need to return to C to split it up too

$$ We$$ll eventually $$run out$$ of spaces for further subdivisions $($and doors$)$

$$ Because doors are $$cut$$ into newly$-$added walls, we$$ll never need to touch a wall again after its creation

So$,$ what$$s left? Sooner or later, they$$ll all be divided $$enough$.$ e$.$g$.$:

We$$re still missing three things: doors, the cutoff for $$when to stop dividing$,$ and $$the Piet Mondrian part$.$

$$ Doors are easy; we could$$ve been doing them the whole time: when installing a wall and leaving a gap, simply make

an orange line instead of the gap

$$ The cutoff is relatively simple: allow for a cutoff value where a room having either dimension at or below that value

will never be further divided; also include some probability to stop even sooner than that. When testing, $$below $3$ is

a nice cutoff to try using, along with a $$quitting proclivity$$ of ~$5\%$

$$ This doesn$$t mean it$$s impossible for a room to have e$.$g$.$ a height of $2$: a room $20$ tall could be divided into one

of $18$ and one of $2($or even one of $19$ and one of $1!)$

$$ Some of the final room$-$floors will have their floor painted a random colour

$$ This will occur with some probability, to be decided specifically when a room will no longer be further divided

Overall, it seems pretty doable, right? Or maybe not? This task is specifically designed to require significant planning

before coding.

Some basic requirements are included, but as always: this is a continuation from COSC$1$P$03($and also $1$P$02).$ You$$re

expected to know basic standards. If not, ask.

Basic requirements:

$$ First and foremost: this is a recursive algorithm. It must be done recursively, with recursion

$$ It must also be done correctly with recursion. e$.$g$.$ don$$t be peppering instance variables about, willy$-$nilly. That$$s

objectively bad. Instead, remember that parameters are a thing!

$$ Some closely$-$related values need to be defined. e$.$g$.$ the width and height of the $$floor$,$ both in pixels and in $$cells$$;

but also the size of a cell, and the number of cells in each direction. Some of those will be calculated from the others

$$ Let the user select the non$-$calculated ones. To be clear: this doesn$$t mean $$let the user edit$/$fix your code,

recompile, and do all the actual work$$

$$ All UI elements are based on the Brock library you used for $1$P$02/1$P$03.$ To ensure we$$re on