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

drawOctagon()
pen.move(distance: 100)
drawOctagon()
pen.move(distance: 100)
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
    let bg = Pen()
    bg.fillColor = .red
    for _ in 1...2 {
        bg.addLine(distance: 28 * scale)
        bg.turn(degrees: 90)
        bg.addLine(distance: 21 * scale)
        bg.turn(degrees: 90)
    }
    pen.addShape(pen: bg)

    // White cross
    let hBar = Pen()
    hBar.fillColor = .white
    for _ in 1...2 {
        hBar.addLine(distance: 28 * scale)
        hBar.turn(degrees: 90)
        hBar.addLine(distance: 4 * scale)
        hBar.turn(degrees: 90)
    }
    pen.addShape(pen: hBar)
}

drawDenmark(scale: 5)

func drawSweden(scale: Double) {
    let 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)
    }
    pen.addShape(pen: bg)
    // Yellow cross bars drawn at offsets
    let cross = Pen(); cross.fillColor = .yellow
    for _ in 1...2 {
        cross.addLine(distance: 16*scale); cross.turn(degrees:90)
        cross.addLine(distance: 2*scale); cross.turn(degrees:90)
    }
    pen.addShape(pen: cross)
}
drawSweden(scale: 8)

// Draw layers: red bg → white cross (wider) → blue cross (narrower)
// Use pen.move() with negative distances to reposition between layers
func drawCrossBar(width: Double, thickness: Double, color: Color) {
    let bar = Pen(); bar.fillColor = color
    for _ in 1...2 {
        bar.addLine(distance: width); bar.turn(degrees:90)
        bar.addLine(distance: thickness); bar.turn(degrees:90)
    }
    pen.addShape(pen: bar)
}

import Foundation
let w: Double = 200, h: Double = 120
let diag = sqrt(w*w + h*h)
let angle = atan2(h, w) * 180 / .pi

// Diagonal 1: bottom-left to top-right
pen.addLine(distance: diag)
pen.move(distance: -diag)

// Diagonal 2: top-left to bottom-right
pen.turn(degrees: -angle * 2)
pen.addLine(distance: diag)

// Reuse the St Andrew approach:
// 1. Draw white background rectangle
// 2. Set pen colour to red
// 3. Draw diagonals using sqrt(w²+h²)

func drawStGeorge(scale: Double) {
    // White background 3:2 proportions
    let bg = Pen(); bg.fillColor = .white
    for _ in 1...2 {
        bg.addLine(distance:30*scale); bg.turn(degrees:90)
        bg.addLine(distance:20*scale); bg.turn(degrees:90)
    }
    pen.addShape(pen: bg)
    // Red centred cross — horizontal and vertical bars
    let hBar = Pen(); hBar.fillColor = .red
    for _ in 1...2 {
        hBar.addLine(distance:30*scale); hBar.turn(degrees:90)
        hBar.addLine(distance:4*scale); hBar.turn(degrees:90)
    }
    pen.addShape(pen: hBar)
}
drawStGeorge(scale: 5)

// Call your existing functions in order:
// 1. drawBlueBackground()
// 2. drawSaltire(color: .white, thickness: 8)  // St Andrew
// 3. drawSaltire(color: .red, thickness: 4)    // St Patrick
// 4. drawCentredCross(color: .red, width: 6)   // St George

func drawStar(points: Int, size: Double, color: Color) {
    let angle = Double(180 - 180/points) * 2
    let star = Pen(); star.fillColor = color
    for _ in 1...points {
        star.addLine(distance: size)
        star.turn(degrees: angle)
    }
    pen.addShape(pen: star)
}
drawStar(points: 5, size: 80, color: .yellow)

// Use pen.move() to position each element:
// 1. Blue background rectangle
// 2. Union Jack scaled to top-left quadrant
// 3. drawStar(points: 7, ...) below Union Jack
// 4. Southern Cross: 4 large + 1 small star

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

drawStripe(width: 200, height: 40, color: .red)
pen.turn(degrees: 270); pen.move(distance: 40); pen.turn(degrees: 90)
drawStripe(width: 200, height: 40, color: .white)
pen.turn(degrees: 270); pen.move(distance: 40); pen.turn(degrees: 90)
drawStripe(width: 200, height: 40, color: .blue)

// Draw three side-by-side rectangles (each 1/3 the total width)
// After each stripe, move right by stripe width to start the next
drawStripe(width: 60, height: 120, color: .blue)
pen.move(distance: 60)
drawStripe(width: 60, height: 120, color: .white)
pen.move(distance: 60)
drawStripe(width: 60, height: 120, color: .red)

func drawFrance(x: Double, y: Double, scale: Double) {
    pen.move(distance: x)
    pen.turn(degrees: 90)
    pen.move(distance: y)
    pen.turn(degrees: -90)
    // ... draw flag at current position
}

drawFrance(x: 0, y: 0, scale: 1)
drawNetherlands(x: 220, y: 0, scale: 1)
drawDenmark(x: 440, y: 0, scale: 1)

// Swiss flag: 1:1 square ratio
// Cross: two rectangles sized 1/6 × 2/3 of flag width
// Centred: offset = (flag_width - cross_arm) / 2
let size: Double = 180
let arm = size / 5
let long = size * 3 / 5
let offset = (size - arm) / 2

// 1. Red background (full flag)
// 2. White rectangle: top-left, width/height ≈ 1/3 of flag
// 3. Red cross centred within the white rectangle

// 5 stripes alternating red/white
let colors: [Color] = [.red, .white, .red, .white, .red]
// Triangle left-side isoceles pointing right
// Star centred in triangle

// Outer loop: 11 rows (6 of 5 stars + 5 of 4 stars)
for row in 0..<11 {
    let starsInRow = row % 2 == 0 ? 6 : 5
    let xOffset = row % 2 == 0 ? 0 : starSpacing / 2
    for col in 0..<starsInRow {
        // position and draw small star
    }
}