HedgehogBox.foocad

A box for hibernating hedgehogs. The box is made from planks of wood in two "stories". Cut one plank in half lengthways (see halfDecking)

The roof is a cheap paving slab.

Build the two stories, and then connect them with a few pocket hole screws. Then attach the floor from the bottom. NOTE. The floor needs small gaps (4mm?) for expansion.

Finally add the light green "tilt" piece. I'm not sure if this is needed. The idea is to lift the floor up slightly, and ensure that water cannot pool in the sleeping quarters ;-)

Note, in the rendered version the floor extends beyond the entrance. This last plank can be cut flush with the box. The offcut can be used for the light green "tilt" piece ;-)

Each year, add a new corregated cardboard carpet ;-) and some straw.

For a professionally made version see : [https://www.green-feathers.co.uk/collections/bird-boxes/products/eco-friendly-hedgehog-house]

FooCAD Source Code

import static uk.co.nickthecoder.foocad.layout.v1.Layout2d.*
import static uk.co.nickthecoder.foocad.layout.v1.Layout3d.*
import static uk.co.nickthecoder.foocad.along.v2.Along.*

class HedgehogBox : Model {

    val tileSize = Vector3( 450, 450, 25 )
    var size = Vector2( 420, 400 )

    override fun build() : Shape3d {

        val decking = Lumber( "main", 120, 25 )
        val halfDecking = Lumber( "main", 60, 25 )
        val batton = Lumber( "batton", 32, 32 )

        val frontBack1 = decking.cut( size.x )    
            .label("frontBack")
            .alongX().rotateX(90)
            .translateY(size.y - decking.thickness).also()
        val frontBack2 = halfDecking.cut( size.x )    
            .label("frontBack")
            .alongX().rotateX(90)
            .translateY(size.y - decking.thickness).also()
            .bottomTo( frontBack1.top + 1 )
        val frontBack = frontBack1 + frontBack2

        val leftRight = decking.cut( size.y - decking.thickness * 2 )
            .color("Green")
            .alongY()
        val leftRight2 = halfDecking.cut( size.y - decking.thickness * 2 )
            .color("Green")
            .alongY()
            .bottomTo( leftRight.top + 1 )

        val left1 = leftRight
            .label( "left1" )
        val left2 = halfDecking.cut( size.y - decking.thickness * 2 )
            .label( "left2" )
            .color("Green")
            .alongY()
            .bottomTo( left1.top + 1 )
        val left = left1 + left2

        val opening = decking.cut( size.y - decking.thickness * 2 - decking.width )
            .color("Green")
            .alongY()

        val right = (opening + leftRight2)
            .rightTo( size.x )
        val mid = right.mirrorY()
            .frontTo(0)
            .rightTo( right.left - decking.width )

        val roof = Cube( tileSize )
            .centerTo( size.x / 2, size.y / 2 - decking.thickness, 0 )
            .bottomTo( decking.width * 1.5 + 1 )
            .previewOnly()

        val entrance = batton.cut( decking.width + decking.thickness * 2 )
            .alongY()
            .color( "LightGreen")
            .leftTo( right.right )
            .backTo( frontBack.back )
            .bottomTo( decking.width )

        val floor = decking.cut( size.y )
            .label( "floor" )
            .rotateX(-90)
            .frontTo( - decking.thickness )
            .tileX(4, 4)
            .color( "White" )

        val tilt = batton.cut( size.y )
            .label("tilt")
            .alongY()
            .frontTo( -decking.thickness )
            .topTo(floor.bottom)
            .color( "LightGreen")

        return frontBack + left + right + mid + roof + entrance + tilt + floor
    }
}