func drawOctagon() {
    for _ in 1...8 {
        pen.addLine(distance: 40)
        pen.turn(degrees: 45)
    }
}

// Three octagons in a row, separated by pen.move
drawOctagon()
pen.move(distance: 110)
drawOctagon()
pen.move(distance: 110)
drawOctagon()

func drawRegularPolygon(sides: Int, sideLength: Double) {
    let angle = 360.0 / Double(sides)
    for _ in 1...sides {
        pen.addLine(distance: sideLength)
        pen.turn(degrees: angle)
    }
}

drawRegularPolygon(sides: 3, sideLength: 60)
pen.move(distance: 80)
drawRegularPolygon(sides: 4, sideLength: 60)
pen.move(distance: 80)
drawRegularPolygon(sides: 5, sideLength: 60)
pen.move(distance: 80)
drawRegularPolygon(sides: 6, sideLength: 60)
pen.move(distance: 80)
drawRegularPolygon(sides: 8, sideLength: 60)

func drawRectangle(width: Double, height: Double, color: Color) {
    let shape = Pen()
    shape.fillColor = color
    for _ in 1...2 {
        shape.addLine(distance: width)
        shape.turn(degrees: 90)
        shape.addLine(distance: height)
        shape.turn(degrees: 90)
    }
    pen.addShape(pen: shape)
}

func drawDenmark(scale: Double) {
    // Red background (28 × 21)
    var bg = Pen()
    bg.fillColor = .red
    bg.penColor = .red
    for _ in 1...2 {
        bg.addLine(distance: 28 * scale)
        bg.turn(degrees: 90)
        bg.addLine(distance: 21 * scale)
        bg.turn(degrees: 90)
    }
    addShape(pen: bg)

    // White horizontal bar (full width, 4 units tall, centred vertically)
    var hBar = Pen()
    hBar.penColor = .white
    hBar.fillColor = .white
    hBar.goto(x: 0, y: 8.5 * scale)
    for _ in 1...2 {
        hBar.addLine(distance: 28 * scale)
        hBar.turn(degrees: 90)
        hBar.addLine(distance: 4 * scale)
        hBar.turn(degrees: 90)
    }
    addShape(pen: hBar)

    // White vertical bar (full height, 4 units wide, offset left)
    var vBar = Pen()
    vBar.penColor = .white
    vBar.fillColor = .white
    vBar.goto(x: 10 * scale, y: 0)
    for _ in 1...2 {
        vBar.addLine(distance: 4 * scale)
        vBar.turn(degrees: 90)
        vBar.addLine(distance: 21 * scale)
        vBar.turn(degrees: 90)
    }
    addShape(pen: vBar)
}

drawDenmark(scale: 10)

func drawSweden(scale: Double) {
    // Blue background (16 × 10)
    var bg = Pen()
    bg.fillColor = .blue
    for _ in 1...2 {
        bg.addLine(distance: 16 * scale)
        bg.turn(degrees: 90)
        bg.addLine(distance: 10 * scale)
        bg.turn(degrees: 90)
    }
    addShape(pen: bg)

    // Yellow horizontal bar (full width, 2 units tall, y = (10 - 2)/2 = 4)
    var hBar = Pen()
    hBar.penColor = .yellow
    hBar.fillColor = .yellow
    hBar.goto(x: 0, y: 4 * scale)
    for _ in 1...2 {
        hBar.addLine(distance: 16 * scale)
        hBar.turn(degrees: 90)
        hBar.addLine(distance: 2 * scale)
        hBar.turn(degrees: 90)
    }
    addShape(pen: hBar)

    // Yellow vertical bar (full height, 2 units wide, offset left at x = 5)
    var vBar = Pen()
    vBar.penColor = .yellow
    vBar.fillColor = .yellow
    vBar.goto(x: 5 * scale, y: 0)
    for _ in 1...2 {
        vBar.addLine(distance: 2 * scale)
        vBar.turn(degrees: 90)
        vBar.addLine(distance: 10 * scale)
        vBar.turn(degrees: 90)
    }
    addShape(pen: vBar)
}

drawSweden(scale: 8)

func drawNorway(scale: Double) {
    // Norway proportions: 22 × 16
    // Cross centre: x = 6 from left, thicknesses: white = 4, blue = 2

    // --- Helper: draws a rectangle at a given position ---
    func drawRect(x: Double, y: Double,
                  w: Double, h: Double, color: UIColor) {
        var p = Pen()
        p.penColor = color
        p.fillColor = color
        p.goto(x: x * scale, y: y * scale)
        for _ in 1...2 {
            p.addLine(distance: w * scale)
            p.turn(degrees: 90)
            p.addLine(distance: h * scale)
            p.turn(degrees: 90)
        }
        addShape(pen: p)
    }

    // Layer 1: Red background (22 × 16)
    drawRect(x: 0, y: 0, w: 22, h: 16, color: .red)

    // Layer 2: White cross (thickness 4)
    drawRect(x: 0, y: 6, w: 22, h: 4, color: .white)  // horizontal
    drawRect(x: 6, y: 0, w: 4, h: 16, color: .white)  // vertical

    // Layer 3: Blue cross (thickness 2, centred within white)
    drawRect(x: 0, y: 7, w: 22, h: 2, color: .blue)   // horizontal
    drawRect(x: 7, y: 0, w: 2, h: 16, color: .blue)   // vertical
}

drawNorway(scale: 6)

import Foundation
import UIKit

func drawStAndrew(scale: Double) {
    // St Andrew's Cross (Saltire): 5:3 ratio, e.g. 30 × 18
    let w: Double = 30 * scale
    let h: Double = 18 * scale

    // Saltire "thickness" measured as offset along the horizontal edges.
    // For a 5:3 flag, t = w/5 → perpendicular bar thickness of h/5.
    let t: Double = w / 5

    // --- Blue background ---
    var bg = Pen()
    bg.fillColor = .blue
    for _ in 1...2 {
        bg.addLine(distance: w)
        bg.turn(degrees: 90)
        bg.addLine(distance: h)
        bg.turn(degrees: 90)
    }
    addShape(pen: bg)

    // --- White saltire bar 1: bottom-left → top-right ---
    // Vertices (CCW): BL corner → bottom edge offset → TR corner → top edge offset
    let bar1 = Polygon(vertices: [
        Point(x: 0,     y: 0),   // bottom-left corner
        Point(x: t,     y: 0),   // bottom edge, offset right by t
        Point(x: w,     y: h),   // top-right corner
        Point(x: w - t, y: h)    // top edge, offset left by t
    ])
    addFilledPolygon(bar1, fillColor: .white, borderColor: .white, lineWidth: 1)

    // --- White saltire bar 2: top-left → bottom-right ---
    let bar2 = Polygon(vertices: [
        Point(x: 0,     y: h),   // top-left corner
        Point(x: t,     y: h),   // top edge, offset right by t
        Point(x: w,     y: 0),   // bottom-right corner
        Point(x: w - t, y: 0)    // bottom edge, offset left by t
    ])
    addFilledPolygon(bar2, fillColor: .white, borderColor: .white, lineWidth: 1)
}

drawStAndrew(scale: 8)

import Foundation
import UIKit

func drawStPatrick(scale: Double) {
    // St Patrick's Cross: 5:3 ratio, e.g. 30 × 18
    let w: Double = 30 * scale
    let h: Double = 18 * scale
    let t: Double = w / 5

    // --- White background ---
    var bg = Pen()
    bg.fillColor = .white
    bg.penColor = .white
    for _ in 1...2 {
        bg.addLine(distance: w)
        bg.turn(degrees: 90)
        bg.addLine(distance: h)
        bg.turn(degrees: 90)
    }
    addShape(pen: bg)

    // --- Red saltire bar 1: bottom-left → top-right ---
    let bar1 = Polygon(vertices: [
        Point(x: 0,     y: 0),
        Point(x: t,     y: 0),
        Point(x: w,     y: h),
        Point(x: w - t, y: h)
    ])
    addFilledPolygon(bar1, fillColor: .red, borderColor: .red, lineWidth: 1)

    // --- Red saltire bar 2: top-left → bottom-right ---
    let bar2 = Polygon(vertices: [
        Point(x: 0,     y: h),
        Point(x: t,     y: h),
        Point(x: w,     y: 0),
        Point(x: w - t, y: 0)
    ])
    addFilledPolygon(bar2, fillColor: .red, borderColor: .red, lineWidth: 1)
}

drawStPatrick(scale: 8)

import Foundation
import UIKit

func drawStGeorge(scale: Double) {
    // St George's Cross: 30 × 20, cross width 4, centred

    func drawRect(x: Double, y: Double,
                  w: Double, h: Double, color: UIColor) {
        var p = Pen()
        p.penColor = color
        p.fillColor = color
        p.goto(x: x * scale, y: y * scale)
        for _ in 1...2 {
            p.addLine(distance: w * scale)
            p.turn(degrees: 90)
            p.addLine(distance: h * scale)
            p.turn(degrees: 90)
        }
        addShape(pen: p)
    }

    // White background (30 × 20)
    drawRect(x: 0, y: 0, w: 30, h: 20, color: .white)

    // Red cross — centred both ways
    drawRect(x: 0,  y: 8, w: 30, h: 4, color: .red)   // horizontal
    drawRect(x: 13, y: 0, w: 4, h: 20, color: .red)   // vertical
}

drawStGeorge(scale: 5)

import Foundation
import UIKit

func drawUnionJack(scale: Double) {
    // Union Jack: 2:1 ratio, e.g. 60 × 30
    let w: Double = 60 * scale
    let h: Double = 30 * scale
    let diag: Double = sqrt(w*w + h*h)

    // Heraldic thicknesses (as fractions of the hoist)
    let whiteSaltireT: Double = h / 5    // St Andrew — 1/5 of hoist
    let redSaltireT:   Double = h / 15   // St Patrick — 1/15 of hoist
    let whiteCrossT:   Double = h / 3    // St George backing — 1/3 of hoist
    let redCrossT:     Double = h / 5    // St George — 1/5 of hoist

    // --- Helpers ---

    func drawRect(x: Double, y: Double,
                  w rw: Double, h rh: Double, color: UIColor) {
        var p = Pen()
        p.penColor = color
        p.fillColor = color
        p.goto(x: x, y: y)
        for _ in 1...2 {
            p.addLine(distance: rw)
            p.turn(degrees: 90)
            p.addLine(distance: rh)
            p.turn(degrees: 90)
        }
        addShape(pen: p)
    }

    // Draws one saltire as two hexagons — one per diagonal — with long edges
    // EXACTLY parallel to the flag's main diagonal (w, h). T = perpendicular
    // thickness. eh/ew = offsets where the strip hits the flag edges.
    func drawSaltire(color: UIColor, perpendicular T: Double) {
        let eh = T * diag / (2 * h)
        let ew = T * diag / (2 * w)

        // Bar 1: bottom-left → top-right diagonal (hexagon, CCW)
        let bar1 = Polygon(vertices: [
            Point(x: 0,      y: 0),          // BL corner
            Point(x: eh,     y: 0),          // bottom edge entry
            Point(x: w,      y: h - ew),     // right edge exit
            Point(x: w,      y: h),          // TR corner
            Point(x: w - eh, y: h),          // top edge exit
            Point(x: 0,      y: ew)          // left edge entry
        ])
        addFilledPolygon(bar1, fillColor: color, borderColor: color, lineWidth: 1)

        // Bar 2: top-left → bottom-right diagonal (hexagon, CCW)
        let bar2 = Polygon(vertices: [
            Point(x: 0,      y: h),          // TL corner
            Point(x: 0,      y: h - ew),     // left edge entry
            Point(x: w - eh, y: 0),          // bottom edge exit
            Point(x: w,      y: 0),          // BR corner
            Point(x: w,      y: ew),         // right edge exit
            Point(x: eh,     y: h)           // top edge entry
        ])
        addFilledPolygon(bar2, fillColor: color, borderColor: color, lineWidth: 1)
    }

    func drawCenteredCross(color: UIColor, thickness t: Double) {
        drawRect(x: 0,           y: (h - t) / 2, w: w, h: t, color: color)
        drawRect(x: (w - t) / 2, y: 0,           w: t, h: h, color: color)
    }

    // --- Layer order (bottom → top) ---

    // 1. Blue background
    drawRect(x: 0, y: 0, w: w, h: h, color: .blue)

    // 2. White St Andrew saltire
    drawSaltire(color: .white, perpendicular: whiteSaltireT)

    // 3. Red St Patrick saltire (centred in the white, parallel to it)
    drawSaltire(color: .red, perpendicular: redSaltireT)

    // 4. White backing for St George (fimbriation)
    drawCenteredCross(color: .white, thickness: whiteCrossT)

    // 5. Red St George cross
    drawCenteredCross(color: .red, thickness: redCrossT)
}

drawUnionJack(scale: 4)

import UIKit

func drawStarNK(at position: Point, n: Int, k: Int,
                size: Double, color: UIColor) {
    // General star polygon {n/k} turn angle = 360 × k / n
    // Produces a valid single-pass star when gcd(n, k) = 1 and k ≥ 2
    let angle = 360.0 * Double(k) / Double(n)

    var star = Pen()
    star.penColor = color
    star.fillColor = color
    star.goto(x: position.x, y: position.y)

    for _ in 0..<n {
        star.addLine(distance: size)
        star.turn(degrees: angle)
    }
    addShape(pen: star)
}

drawStarNK(at: Point(x: -120, y: 0), n: 5, k: 2, size: 80, color: .systemYellow)  // classic 5-star
drawStarNK(at: Point(x:    0, y: 0), n: 7, k: 2, size: 80, color: .systemOrange)  // 7/2 star
drawStarNK(at: Point(x:  120, y: 0), n: 7, k: 3, size: 80, color: .systemRed)     // 7/3 star (denser)

import Foundation
import UIKit

// ============================================================
// Star polygon {n/k} centred at a point, oriented point-up.
// Cleaner than drawStarNK for composition — pass the centre.
// ============================================================
func drawStarCentered(at center: Point, n: Int, k: Int,
                      size: Double, color: UIColor) {
    // Circumradius: s = 2R·sin(πk/n) ⇒ R = s/(2·sin(πk/n))
    let R = size / (2 * sin(.pi * Double(k) / Double(n)))

    // Place V₀ at top of circle (point-up), aim pen at V₁.
    // atan2 of (V₁ − V₀) simplifies to 180° + 180°k/n.
    let initialHeadingDeg = 180.0 + 180.0 * Double(k) / Double(n)
    let turnDeg = 360.0 * Double(k) / Double(n)

    var star = Pen()
    star.penColor = color
    star.fillColor = color

    star.goto(x: center.x, y: center.y + R)
    star.turn(degrees: initialHeadingDeg)

    for _ in 0..<n {
        star.addLine(distance: size)
        star.turn(degrees: turnDeg)
    }
    addShape(pen: star)
}

// ============================================================
// Union Jack — now accepts a position
// ============================================================
func drawUnionJack(at pos: Point, scale: Double) {
    let w: Double = 60 * scale
    let h: Double = 30 * scale
    let diag: Double = sqrt(w*w + h*h)

    let whiteSaltireT: Double = h / 5
    let redSaltireT:   Double = h / 15
    let whiteCrossT:   Double = h / 3
    let redCrossT:     Double = h / 5

    func drawRect(x: Double, y: Double,
                  w rw: Double, h rh: Double, color: UIColor) {
        var p = Pen()
        p.penColor = color
        p.fillColor = color
        p.goto(x: pos.x + x, y: pos.y + y)
        for _ in 1...2 {
            p.addLine(distance: rw)
            p.turn(degrees: 90)
            p.addLine(distance: rh)
            p.turn(degrees: 90)
        }
        addShape(pen: p)
    }

    func drawSaltire(color: UIColor, perpendicular T: Double) {
        let eh = T * diag / (2 * h)
        let ew = T * diag / (2 * w)

        let bar1 = Polygon(vertices: [
            Point(x: pos.x,          y: pos.y),
            Point(x: pos.x + eh,     y: pos.y),
            Point(x: pos.x + w,      y: pos.y + h - ew),
            Point(x: pos.x + w,      y: pos.y + h),
            Point(x: pos.x + w - eh, y: pos.y + h),
            Point(x: pos.x,          y: pos.y + ew)
        ])
        addFilledPolygon(bar1, fillColor: color, borderColor: color, lineWidth: 1)

        let bar2 = Polygon(vertices: [
            Point(x: pos.x,          y: pos.y + h),
            Point(x: pos.x,          y: pos.y + h - ew),
            Point(x: pos.x + w - eh, y: pos.y),
            Point(x: pos.x + w,      y: pos.y),
            Point(x: pos.x + w,      y: pos.y + ew),
            Point(x: pos.x + eh,     y: pos.y + h)
        ])
        addFilledPolygon(bar2, fillColor: color, borderColor: color, lineWidth: 1)
    }

    func drawCenteredCross(color: UIColor, thickness t: Double) {
        drawRect(x: 0,           y: (h - t) / 2, w: w, h: t, color: color)
        drawRect(x: (w - t) / 2, y: 0,           w: t, h: h, color: color)
    }

    // Layer order (bottom → top)
    drawRect(x: 0, y: 0, w: w, h: h, color: .blue)
    drawSaltire(color: .white, perpendicular: whiteSaltireT)
    drawSaltire(color: .red,   perpendicular: redSaltireT)
    drawCenteredCross(color: .white, thickness: whiteCrossT)
    drawCenteredCross(color: .red,   thickness: redCrossT)
}

// ============================================================
// AUSTRALIAN FLAG
// ============================================================
func drawAustralia(at pos: Point, scale: Double) {
    let w: Double = 60 * scale
    let h: Double = 30 * scale

    // 1. Blue background
    var bg = Pen()
    bg.penColor = .blue
    bg.fillColor = .blue
    bg.goto(x: pos.x, y: pos.y)
    for _ in 1...2 {
        bg.addLine(distance: w)
        bg.turn(degrees: 90)
        bg.addLine(distance: h)
        bg.turn(degrees: 90)
    }
    addShape(pen: bg)

    // 2. Union Jack canton (top-left quarter, scale/2)
    drawUnionJack(at: Point(x: pos.x, y: pos.y + h / 2),
                  scale: scale / 2)

    // 3. Commonwealth Star — {7/3} for the spiky-heptagram look
    drawStarCentered(
        at: Point(x: pos.x + w / 4, y: pos.y + h / 4),
        n: 7, k: 3,
        size: h * 0.31,
        color: .white
    )

    // 4. Southern Cross — large stars {7/3}, Epsilon {5/2}
    let largeSize: Double = h * 0.14
    let smallSize: Double = h / 13

    // Gamma Crucis (top)
    drawStarCentered(
        at: Point(x: pos.x + 0.72 * w, y: pos.y + 0.80 * h),
        n: 7, k: 3, size: largeSize, color: .white
    )
    // Beta Crucis (left)
    drawStarCentered(
        at: Point(x: pos.x + 0.58 * w, y: pos.y + 0.52 * h),
        n: 7, k: 3, size: largeSize, color: .white
    )
    // Delta Crucis (right)
    drawStarCentered(
        at: Point(x: pos.x + 0.82 * w, y: pos.y + 0.46 * h),
        n: 7, k: 3, size: largeSize, color: .white
    )
    // Alpha Crucis (bottom)
    drawStarCentered(
        at: Point(x: pos.x + 0.72 * w, y: pos.y + 0.20 * h),
        n: 7, k: 3, size: largeSize, color: .white
    )
    // Epsilon Crucis (small 5-point)
    drawStarCentered(
        at: Point(x: pos.x + 0.76 * w, y: pos.y + 0.40 * h),
        n: 5, k: 2, size: smallSize, color: .white
    )
}

drawAustralia(at: Point(x: -120, y: -60), scale: 7)

import Foundation
import UIKit

// --- Foundation helper: draws one filled stripe at (x, y) ---
func drawStripe(x: Double, y: Double,
                width w: Double, height h: Double, color: UIColor) {
    var p = Pen()
    p.penColor = color
    p.fillColor = color
    p.goto(x: x, y: y)
    for _ in 1...2 {
        p.addLine(distance: w)
        p.turn(degrees: 90)
        p.addLine(distance: h)
        p.turn(degrees: 90)
    }
    addShape(pen: p)
}

// --- Reusable tricolour helper: 3 equal horizontal stripes ---
// color1 = TOP, color2 = MIDDLE, color3 = BOTTOM.
// y increases upward, so the BOTTOM stripe is drawn first.
func drawTricolour(color1: UIColor, color2: UIColor, color3: UIColor,
                   width: Double, height: Double) {
    let stripeH = height / 3
    drawStripe(x: 0, y: 0,           width: width, height: stripeH, color: color3)
    drawStripe(x: 0, y: stripeH,     width: width, height: stripeH, color: color2)
    drawStripe(x: 0, y: 2 * stripeH, width: width, height: stripeH, color: color1)
}

// --- Dutch flag: red (top), white (middle), blue (bottom), 3:2 ratio ---
func drawNetherlands(scale: Double) {
    drawTricolour(
        color1: .red,     // top
        color2: .white,   // middle
        color3: .blue,    // bottom
        width:  30 * scale,
        height: 20 * scale
    )
}

drawNetherlands(scale: 6)

import Foundation
import UIKit

// drawStripe is the same helper from Section 15 Netherlands.
// Repeated here for a self-contained France solution.
func drawStripe(x: Double, y: Double,
                width w: Double, height h: Double, color: UIColor) {
    var p = Pen()
    p.penColor = color
    p.fillColor = color
    p.goto(x: x, y: y)
    for _ in 1...2 {
        p.addLine(distance: w)
        p.turn(degrees: 90)
        p.addLine(distance: h)
        p.turn(degrees: 90)
    }
    addShape(pen: p)
}

// --- 3 equal VERTICAL stripes ---
// color1 = LEFT (hoist), color2 = MIDDLE, color3 = RIGHT (fly).
// Each stripe has FULL height and 1/3 width; step along x, not y.
func drawTricolourVertical(color1: UIColor, color2: UIColor, color3: UIColor,
                            width: Double, height: Double) {
    let stripeW = width / 3
    drawStripe(x: 0,           y: 0, width: stripeW, height: height, color: color1)
    drawStripe(x: stripeW,     y: 0, width: stripeW, height: height, color: color2)
    drawStripe(x: 2 * stripeW, y: 0, width: stripeW, height: height, color: color3)
}

// --- French flag: blue (hoist), white, red (fly), 3:2 ratio ---
func drawFrance(scale: Double) {
    drawTricolourVertical(
        color1: .blue,    // hoist (left)
        color2: .white,   // middle
        color3: .red,     // fly (right)
        width:  30 * scale,
        height: 20 * scale
    )
}

drawFrance(scale: 6)

import Foundation
import UIKit

// Filled rectangle at an absolute position.
// This single helper replaces every inline rectangle loop from Sections 06–16.
func drawRectAt(at pos: Point,
                w: Double, h: Double, color: UIColor) {
    var p = Pen()
    p.penColor = color
    p.fillColor = color
    p.goto(x: pos.x, y: pos.y)
    for _ in 1...2 {
        p.addLine(distance: w)
        p.turn(degrees: 90)
        p.addLine(distance: h)
        p.turn(degrees: 90)
    }
    addShape(pen: p)
}

// Now each flag function takes (at: Point, scale: Double) and uses drawRectAt.
// Example: France, Netherlands, Denmark side by side on the same canvas.

func drawFrance(at pos: Point, scale: Double) {
    let w: Double = 30 * scale
    let h: Double = 20 * scale
    let stripe = w / 3
    drawRectAt(at: Point(x: pos.x,              y: pos.y), w: stripe, h: h, color: .blue)
    drawRectAt(at: Point(x: pos.x + stripe,     y: pos.y), w: stripe, h: h, color: .white)
    drawRectAt(at: Point(x: pos.x + 2 * stripe, y: pos.y), w: stripe, h: h, color: .red)
}

func drawNetherlands(at pos: Point, scale: Double) {
    let w: Double = 30 * scale
    let h: Double = 20 * scale
    let stripe = h / 3
    drawRectAt(at: Point(x: pos.x, y: pos.y + 2 * stripe), w: w, h: stripe, color: .red)
    drawRectAt(at: Point(x: pos.x, y: pos.y + stripe),     w: w, h: stripe, color: .white)
    drawRectAt(at: Point(x: pos.x, y: pos.y),              w: w, h: stripe, color: .blue)
}

func drawDenmark(at pos: Point, scale: Double) {
    let w: Double = 28 * scale
    let h: Double = 21 * scale
    drawRectAt(at: Point(x: pos.x,              y: pos.y),
               w: w, h: h, color: .red)
    drawRectAt(at: Point(x: pos.x,              y: pos.y + 8.5 * scale),
               w: w, h: 4 * scale, color: .white)
    drawRectAt(at: Point(x: pos.x + 10 * scale, y: pos.y),
               w: 4 * scale, h: h, color: .white)
}

// Three flags side by side, centred around origin
drawFrance(     at: Point(x: -105, y: -20), scale: 2)
drawNetherlands(at: Point(x:  -35, y: -20), scale: 2)
drawDenmark(    at: Point(x:   35, y: -21), scale: 2)

import Foundation
import UIKit

// Filled rectangle at an absolute position (from Section 17)
func drawRectAt(at pos: Point,
                w: Double, h: Double, color: UIColor) {
    var p = Pen()
    p.penColor = color
    p.fillColor = color
    p.goto(x: pos.x, y: pos.y)
    for _ in 1...2 {
        p.addLine(distance: w)
        p.turn(degrees: 90)
        p.addLine(distance: h)
        p.turn(degrees: 90)
    }
    addShape(pen: p)
}

func drawSwitzerland(at pos: Point, scale: Double) {
    // Swiss flag: 1:1 square, cross arms 1/6 wide × 2/3 long
    let size: Double = 30 * scale
    let arm  = size / 6       // cross thickness
    let long = size * 2 / 3   // length of each cross bar

    // 1. Red square background
    drawRectAt(at: pos, w: size, h: size, color: .red)

    // 2. White horizontal bar (long × arm, centred)
    drawRectAt(
        at: Point(x: pos.x + (size - long) / 2,
                  y: pos.y + (size - arm)  / 2),
        w: long, h: arm, color: .white
    )

    // 3. White vertical bar (arm × long, centred)
    drawRectAt(
        at: Point(x: pos.x + (size - arm)  / 2,
                  y: pos.y + (size - long) / 2),
        w: arm, h: long, color: .white
    )
}

// Draw centred on the canvas origin
drawSwitzerland(at: Point(x: -90, y: -90), scale: 6)

import Foundation
import UIKit

// Filled rectangle at an absolute position (from Section 17)
func drawRectAt(at pos: Point,
                w: Double, h: Double, color: UIColor) {
    var p = Pen()
    p.penColor = color
    p.fillColor = color
    p.goto(x: pos.x, y: pos.y)
    for _ in 1...2 {
        p.addLine(distance: w)
        p.turn(degrees: 90)
        p.addLine(distance: h)
        p.turn(degrees: 90)
    }
    addShape(pen: p)
}

// --- Generalised helper: centred plus-cross inside any rectangular box ---
// (works for both Switzerland and Tonga's canton)
func drawCrossInBox(at pos: Point,
                    boxW: Double, boxH: Double,
                    arm: Double, long: Double,
                    color: UIColor) {
    // Horizontal bar: length `long`, thickness `arm`
    drawRectAt(
        at: Point(x: pos.x + (boxW - long) / 2,
                  y: pos.y + (boxH - arm)  / 2),
        w: long, h: arm, color: color
    )
    // Vertical bar: thickness `arm`, length `long`
    drawRectAt(
        at: Point(x: pos.x + (boxW - arm)  / 2,
                  y: pos.y + (boxH - long) / 2),
        w: arm, h: long, color: color
    )
}

// --- Tonga: red field, white canton top-left, red cross inside canton ---
func drawTonga(at pos: Point, scale: Double) {
    // Flag: 2:1 ratio (e.g. 48 × 24)
    let w: Double = 48 * scale
    let h: Double = 24 * scale

    // Canton: ~3/8 of flag width × 1/2 of flag height, top-left
    let cantonW = w * 3 / 8
    let cantonH = h / 2
    let cantonPos = Point(x: pos.x, y: pos.y + h - cantonH)

    // Red cross proportions within the canton
    let arm  = cantonH / 5
    let long = cantonH * 4 / 5

    // 1. Red background
    drawRectAt(at: pos, w: w, h: h, color: .red)

    // 2. White canton (top-left)
    drawRectAt(at: cantonPos, w: cantonW, h: cantonH, color: .white)

    // 3. Red cross centred inside the canton
    drawCrossInBox(
        at: cantonPos,
        boxW: cantonW, boxH: cantonH,
        arm: arm, long: long,
        color: .red
    )
}

drawTonga(at: Point(x: -96, y: -48), scale: 4)

import Foundation
import UIKit

// =====================================================================
// SHARED HELPERS
// =====================================================================

// Filled rectangle at an absolute position
func drawRectAt(at pos: Point,
                w: Double, h: Double, color: UIColor) {
    var p = Pen()
    p.penColor = color
    p.fillColor = color
    p.goto(x: pos.x, y: pos.y)
    for _ in 1...2 {
        p.addLine(distance: w)
        p.turn(degrees: 90)
        p.addLine(distance: h)
        p.turn(degrees: 90)
    }
    addShape(pen: p)
}

// General star polygon {n/k} centred at a point, oriented point-up.
// Works for any valid {n/k} — {5/2} pentagram, {7/2} heptagram, {7/3} spiky.
func drawStarCentered(at center: Point, n: Int, k: Int,
                      size: Double, color: UIColor) {
    // Circumradius: chord length s = 2R·sin(πk/n) ⇒ R = s/(2·sin(πk/n))
    let R = size / (2 * sin(.pi * Double(k) / Double(n)))

    // Place V₀ at top of circle (point-up), aim pen at V₁.
    let initialHeadingDeg = 180.0 + 180.0 * Double(k) / Double(n)
    let turnDeg = 360.0 * Double(k) / Double(n)

    var star = Pen()
    star.penColor = color
    star.fillColor = color

    star.goto(x: center.x, y: center.y + R)
    star.turn(degrees: initialHeadingDeg)

    for _ in 0..<n {
        star.addLine(distance: size)
        star.turn(degrees: turnDeg)
    }
    addShape(pen: star)
}

// =====================================================================
// PUERTO RICO
// =====================================================================

func drawPuertoRico(at pos: Point, scale: Double) {
    // Flag: 3:2 ratio (e.g. 60 × 40)
    let w: Double = 60 * scale
    let h: Double = 40 * scale
    let stripeH = h / 5

    // 1. Five horizontal stripes — red/white/red/white/red (bottom → top)
    let stripes: [UIColor] = [.red, .white, .red, .white, .red]
    for (i, color) in stripes.enumerated() {
        drawRectAt(
            at: Point(x: pos.x, y: pos.y + Double(i) * stripeH),
            w: w, h: stripeH, color: color
        )
    }

    // 2. Blue equilateral triangle, base on left edge, apex pointing right
    // Apex horizontal offset = side × sin(60°) = h × √3 / 2
    let apexX = pos.x + h * sqrt(3) / 2
    let topLeft = Point(x: pos.x, y: pos.y + h)
    let botLeft = Point(x: pos.x, y: pos.y)
    let apex    = Point(x: apexX, y: pos.y + h / 2)

    let tri = Triangle(a: topLeft, b: botLeft, c: apex)
    addFilledTriangle(
        tri,
        fillColor: .blue,
        borderColor: .blue,
        lineWidth: 1
    )

    // 3. White 5-pointed star at the triangle's centroid
    // Centroid of equilateral triangle = (pos.x + h√3/6, pos.y + h/2)
    let centroidX = pos.x + h * sqrt(3) / 6
    let centroidY = pos.y + h / 2
    let starSize  = h / 3

    drawStarCentered(
        at: Point(x: centroidX, y: centroidY),
        n: 5, k: 2,
        size: starSize,
        color: .white
    )
}

drawPuertoRico(at: Point(x: -90, y: -60), scale: 8)

import Foundation
import UIKit

// Assumes drawRectAt and drawStarCentered from earlier sections are defined.

func drawUSA(at pos: Point, scale: Double) {
    // Flag: 19:10 ratio
    let w: Double = 38 * scale
    let h: Double = 20 * scale
    let stripeH = h / 13

    // 1. 13 stripes, bottom-up — red/white alternating, both ends red
    for i in 0..<13 {
        let color: UIColor = (i % 2 == 0) ? .red : .white
        drawRectAt(
            at: Point(x: pos.x, y: pos.y + Double(i) * stripeH),
            w: w, h: stripeH, color: color
        )
    }

    // 2. Blue canton — top-left, covering the top 7 stripes, 0.4 × flag width
    let cantonW = w * 0.4
    let cantonH = 7 * stripeH
    let cantonPos = Point(x: pos.x, y: pos.y + h - cantonH)
    drawRectAt(at: cantonPos, w: cantonW, h: cantonH, color: .blue)

    // 3. 50 stars — 11 rows alternating 5/4/5/4/...
    let rows = 11
    let maxStars = 5
    let rowSpacing = cantonH / Double(rows)
    let colSpacing = cantonW / Double(maxStars)
    let starSize = rowSpacing * 0.7

    for row in 0..<rows {
        let starsInRow = (row % 2 == 0) ? 5 : 4
        // 5-star rows: offset by half a column
        // 4-star rows: offset by a full column
        let xOffset = (row % 2 == 0) ? colSpacing / 2 : colSpacing

        // Row 0 = top of canton; y decreases as row increases
        let rowY = cantonPos.y + cantonH - (Double(row) + 0.5) * rowSpacing

        for col in 0..<starsInRow {
            let starX = cantonPos.x + xOffset + Double(col) * colSpacing

            // drawStarCentered takes the centre directly — no offsets needed.
            drawStarCentered(
                at: Point(x: starX, y: rowY),
                n: 5, k: 2,
                size: starSize,
                color: .white
            )
        }
    }
}

drawUSA(at: Point(x: -76, y: -40), scale: 4)