Advent of Code 2021 in Julia – Day 6: Lanternfish

mutable struct LanternFishes
    timer::Vector{Int}
end

function spawn_fish!(f::LanternFishes, n)
- append!(f.timer, repeat([8], n))
end

function day_forward!(fishes::LanternFishes)
    fishes.timer .-= 1
    spawn_fish!(fishes, sum(fishes.timer .< 0))
    fishes.timer[fishes.timer .< 0] .= 6
end

fishes = parse.(Int, split(strip(input), ",")) |> LanternFishes

for day in 1:80
    day_forward!(fishes)
end

length(fishes.timer) |> print

mutable struct LanternFishes
    timer::Vector{Int64}
end

function day_forward!(f::LanternFishes)
    n_new = f.timer[1]
    f.timer = [f.timer[2:9]; n_new]
    f.timer[7] += n_new
end

fishes = parse.(Int, split(strip(input), ","))
fishes = 0:8 .|> (x -> count(==(x), fishes)) |> LanternFishes

for day in 1:256
    day_forward!(fishes)
end

sum(fishes.timer) |> print

using Agents
using LinearAlgebra

mutable struct Fish <: AbstractAgent
    id::Int                     # |-> required for all agents
    pos::NTuple{2,Float64}      # |
    vel::NTuple{2,Float64}      # -> required for moving agents in ContinousSpeed
    speed::Float64              # -> how far agents travel by vel per steps
    cohere_factor::Float64      # -> maintaining the average position of neighbors
    separation::Float64         # -> minimum distance from its neighbors
    separate_factor::Float64    # -> iportance of maintaining ^separation
    match_factor::Float64       # -> importance of matching the avg trajectory of neighbors
    visual_distance::Float64    # -> distance agents can see
    timer::Float64              # -> timer for spawn
end

function initialize_model(;
    n_fishs = 300,
    speed = 0.75,
    cohere_factor = 0.25,
    separation = 4.0,
    separate_factor = 1,
    match_factor = 0.125,
    visual_distance = 5.0,
    extent = (160, 90),
    spacing = visual_distance / 1.5,
    timers = input
)
    space2d = ContinuousSpace(extent, spacing)
    model = ABM(Fish, space2d, scheduler = Schedulers.randomly)
    for i in 1:n_fishs
        vel = Tuple(rand(model.rng, 2) * 2 .- 1)
        timer = timers[i]
        add_agent!(
            model,
            vel,
            speed,
            cohere_factor,
            separation,
            separate_factor,
            match_factor,
            visual_distance,
            timer,
        )
    end
    return model
end

function agent_step!(fish, model)
    # Obtain the ids of neighbors within the fish's visual distance
    neighbor_ids = nearby_ids(fish, model, fish.visual_distance)
    N = 0
    match = separate = cohere = (0.0, 0.0)
    # Calculate behaviour properties based on neighbors
    for id in neighbor_ids
        N += 1
        neighbor = model[id].pos
        heading = neighbor .- fish.pos
        # `cohere` computes the average position of neighboring fishs
        cohere = cohere .+ heading
        if edistance(fish.pos, neighbor, model) < fish.separation
            # `separate` repels the fish away from neighboring fishs
            separate = separate .- heading
        end
        # `match` computes the average trajectory of neighboring fishs
        match = match .+ model[id].vel
    end
    N = max(N, 1)
    # Normalise results based on model input and neighbor count
    cohere = cohere ./ N .* fish.cohere_factor
    separate = separate ./ N .* fish.separate_factor
    match = match ./ N .* fish.match_factor
    # Compute velocity based on rules defined above
    fish.vel = (fish.vel .+ cohere .+ separate .+ match) ./ 2
    fish.vel = fish.vel ./ norm(fish.vel)
    # Keep fishes in bounds
    if fish.pos[1] >= 155
        fish.vel = fish.vel .- (0.5, 0.0)
    end
    if fish.pos[1] <= 5
        fish.vel = fish.vel .+ (0.5, 0.0)
    end
    if fish.pos[2] >= 85
        fish.vel = fish.vel .- (0.0, 0.5)
    end
    if fish.pos[2] <= 5
        fish.vel = fish.vel .+ (0.0, 0.5)
    end
    # Move fish according to new velocity and speed
    # Fishes move slow when they're newborn
    move_agent!(fish, model, fish.timer <= 6 ? fish.speed : (8-fish.timer)*fish.speed/6)
    # Decrease timer and spawn new fish
    if fish.timer <= 0.0
        fish.timer = 6.0
        add_agent!(
            fish.pos,
            model,
            Tuple(rand(model.rng, 2) * 2 .- 1),
            fish.speed,
            fish.cohere_factor,
            fish.separation,
            fish.separate_factor,
            fish.match_factor,
            fish.visual_distance,
            8.0,
        )
    end
    fish.timer -= 0.1
end

## Plotting the flock
using InteractiveDynamics
using CairoMakie
using ColorSchemes
using Colors

const fish_polygon = Polygon(Point2f0[(-0.5, -0.5), (1, 0), (-0.5, 0.5)])
function fish_marker(b::Fish)
    φ = atan(b.vel[2], b.vel[1]) #+ π/2 + π
    scale(rotate2D(fish_polygon, φ),
          (b.timer <= 6 ? 1 : (8-b.timer)/6)*1 + 1)
end

color_vector = cgrad(:rainbow, 45, categorical=true, rev=true) .|> hex
color_vector = ["#" * c[3:end] for c in color_vector]
agent_color(f) = color_vector[abs(Int(round(f.timer * 5))) + 1]

input = "3,4,3,1,2"
input = parse.(Float64, split(strip(input), ","))

model = initialize_model(n_fishs=length(input),
                         speed=1, visual_distance=5.0, separation=4.0,
                         spacing= 10/3,
                         match_factor=0.1, cohere_factor=0.05, separate_factor=0.25)
abm_video(
    "./Desktop/flocking.mp4", model, agent_step!;
    am = fish_marker, ac = agent_color,
    framerate = 24, frames = 800,
    resolution = (1920, 1080),
    title = "Lantern Fishes")