#lang rhombus/static

export:
    Chunk
    Entity
    World

class Chunk(width :: Int,
            height :: Int,
            offset_x :: Int,
            offset_y :: Int,
            tiles :: Array.now_of(Int),
            neighbours :: MutableMap.now_of(Symbol, Chunk)):
    constructor(width :: Int, height :: Int, offset_x :: Int, offset_y :: Int):
        super(width, height, offset_x, offset_y, Array.make(width * height, 0), MutableMap())

    method get_tile(x :: Int, y :: Int):
        tiles[y * width + x]

class Entity(id:: Int, mutable x :: Int, mutable y :: Int, mutable current_chunk :: Chunk)

class World(chunks :: MutableList.now_of(Chunk),
            entities :: MutableList.now_of(Entity)):

    constructor():
        super(MutableList(), MutableList())

    method
    | entity_move(id :: Int, x :: Int, y :: Int): entity_move(id, x, y, 1)
    | entity_move(id :: Int, x :: Int, y :: Int, max_dist :: Int) :: Boolean:
        let validate_dist = fun (entity :: Entity) :: Boolean:
            let diff_x = math.abs(entity.x - x)
            let diff_y = math.abs(entity.y - y)
            // Diagonal case is moving in the same direction (same x & y) and that amount
            // is less than or equal to max distance
            let diagonal = diff_x == diff_y && diff_x <= max_dist
            let x_axis = diff_x <= max_dist && diff_y == 0
            let y_axis = diff_y <= max_dist && diff_x == 0
            let no_movement = diff_x == 0 && diff_y == 0
            !no_movement && (diagonal || x_axis || y_axis)

        let validate_chunk = fun (entity :: Entity) :: Boolean:
            let current_chunk = entity.current_chunk
            let local_x = x - current_chunk.offset_x * current_chunk.width
            let local_y = y - current_chunk.offset_y * current_chunk.height
            let less_x = local_x < 0
            let less_y = local_y < 0
            let more_x = local_x >= current_chunk.width
            let more_y = local_y >= current_chunk.height
            let inside_x = !(less_x || more_x)
            let inside_y = !(less_y || more_y)
            let next_chunk :: maybe(Chunk) = cond
            | inside_x && less_y: current_chunk.neighbours.get(#'north, #false)
            | more_x && less_y:   current_chunk.neighbours.get(#'north_east, #false)
            | more_x && inside_y: current_chunk.neighbours.get(#'east, #false)
            | more_x && more_y:   current_chunk.neighbours.get(#'south_east, #false)
            | inside_x && more_y: current_chunk.neighbours.get(#'south, #false)
            | less_x && more_y:   current_chunk.neighbours.get(#'south_west, #false)
            | less_x && inside_y: current_chunk.neighbours.get(#'west, #false)
            | less_x && less_y:   current_chunk.neighbours.get(#'north_west, #false)
            | ~else:              current_chunk

            cond
            | !next_chunk: #false
            | ~else:
                entity.current_chunk := next_chunk!!
                #true

        let entity :: maybe(Entity) = entities.find((fun (ent :: Entity) :: Boolean: ent.id == id))
        cond
        | !entity:
            println("Can't find entity")
            #false
        | validate_dist(entity!!) && validate_chunk(entity!!):
            entity!!.x := x
            entity!!.y := y
            #true
        | ~else:
            #false