​

​

let inp = new Map()

let path = new Map()

let detailedPath = []

let guard = null

let startPos

let directions = [

    { x: 0, y: -1 },

    { x: 1, y: 0 },

    { x: 0, y: 1 },

    { x: -1, y: 0 }

]

function setup() {

    createCanvas(800, 700)

    textAlign(CENTER, CENTER)

    parse(myData)

    path.set(1e5 * guard.y + guard.x, { x: guard.x, y: guard.y })

    startPos = { x: guard.x, y: guard.y }

    console.log(inp)

}

​

function step() {

    let nx = guard.x + directions[guard.dir].x

    let ny = guard.y + directions[guard.dir].y

    let p = inp.get(1e5 * ny + nx)

    if (!p) {

        return -1

    } else {

        if (p.val == "#") {

            guard.dir = (guard.dir + 1) % directions.length

        } else {

            guard.x = nx

            guard.y = ny

            guard.steps++

            path.set(1e5 * ny + nx, { x: nx, y: ny })

            guard.steps++

            p = detailedPath.find(e => e.x == nx && e.y == ny && e.dir == guard.dir)

            if (p)

                return -2

​

​

            detailedPath.push({ x: guard.x, y: guard.y, steps: guard.steps, dir: guard.dir })

​

​

        }

    }

​

    return 1

​

}

function part2() {

    let candidates = new Map()

    let saveInp = new Map()

    let savePath = []

    for (let iii of inp)

        saveInp.set(iii[0], iii[1])

    for (let iiii of detailedPath)

        savePath.push(iiii)

​

​

    for (let i = 0; i < savePath.length; i++) {

        inp = new Map()

​

        //re-INIT

        detailedPath = []

        guard = { x: startPos.x, y: startPos.y, dir: 0, steps: 0 }

        detailedPath.push({ x: guard.x, y: guard.y, steps: guard.steps, dir: guard.dir })

        for (let iii of saveInp)

            inp.set(iii[0], iii[1])

        let d = savePath[i]

        inp.set(1e5 * d.y + d.x, { x: d.x, y: d.y, val: "#", step: 0 })

​

        while (true) {

            let s = step()

            if (s == -2) {

                console.log("loop", d.x, d.y)

                candidates.set(1e5 * d.y + d.x, { x: d.x, y: d.y })

            }

            if (s < 0)

                break

        }

    }

    console.log("part2", candidates.size)

}

​

let view

let vel

function draw() {

    background(0)

    noStroke()

    if (!view) {

        view = createVector(0, 0)

        vel = createVector(0, 0)

    }

​

    let delta = createVector(- guard.x * 15 + 400 - view.x, - guard.y * 15 + 300 - view.y)

    delta.setMag(delta.mag() / 50)

    vel.add(delta)

    view.add(vel)

    vel.setMag(vel.mag() / 1.5)

​

    // translate(-guard.x * 15 + 400, -guard.y * 15 + 300)

    translate(view.x, view.y)

    fill(0, 222, 0)

    for (let ss of inp) {

        s = ss[1]

        if (s.val != '.')

            text(s.val, 20 + s.x * 15, 20 + s.y * 15)

    }

​

    fill(222)

    text("O", 20 + guard.x * 15, 20 + guard.y * 15)

​

    for (let i = 0; i < detailedPath.length; i++) {

        let fade = detailedPath.length - i

        fill(Math.max(66, 222 - fade))

        text('x', 20 + detailedPath[i].x * 15, 20 + detailedPath[i].y * 15)

    }

​

​

    // if (guard && frameCount % 5 == 0)

    // for (let i = 0; i < 1000 && isLooping(); i++)

        if (step() == -1) {

            console.log("part1", path.size)

            part2()

            noLoop()

        }

​

}

function parse(sss) {

    let ss = sss.split("\n")

    for (let y = 0; y < ss.length; y++) {

        let s = ss[y].split("")

        for (let x = 0; x < s.length; x++) {

            let val = s[x]

            if (val == "^") {

                guard = { x: x, y: y, dir: 0, steps: 0 }

                detailedPath.push({ x: guard.x, y: guard.y, steps: guard.steps, dir: guard.dir })

​

                val = "."

            }

            inp.set(1e5 * y + x, { x: x, y: y, val: val, step: 0 })

        }

    }

}

​