class Mandelbrot
    export create, update

    var startX, startY : int
    var endX, endY : int
    var offsetX, offsetY : int
    var pixelX, pixelY : int
    var scale : real

    var clr : int

    proc create (x1, y1, x2, y2 : int, magnification : real)
        startX := x1
        startY := y1
        endX := x2
        endY := y2
        offsetX := -startX
        offsetY := -startY
        pixelX := startX
        pixelY := startY
        scale := 1 / magnification
        clr := black
    end create

    fcn updatePixels () : boolean
        if pixelX >= endX and pixelY >= endY then
            result false
        end if
        pixelX += 1
        if pixelX > endX then
            pixelX := startX
            pixelY += 1
        end if
        result true
    end updatePixels

    proc updateMandelbrot ()
        var x := pixelX * scale
        var y := pixelY * scale
        var x0 := x
        var y0 := y

        var x2 := x * x
        var y2 := y * y

        var iteration := 0
        var maxIteration := 1000

        loop
            exit when x2 + y2 > 4 or iteration >= maxIteration

            y := 2 * x * y + y0
            x := x2 - y2 + x0

            x2 := x * x
            y2 := y * y

            iteration += 1
        end loop

        if iteration = maxIteration then
            clr := black
        end if
        clr := (iteration + 1) rem 256
    end updateMandelbrot

    fcn think () : boolean
        if not updatePixels () then
            result false
        end if
        updateMandelbrot ()
        result true
    end think

    proc render ()
        Draw.Dot (pixelX + offsetX, pixelY + offsetY, clr)
    end render

    fcn update () : boolean
        if not think () then
            result false
        end if
        render ()
        result true
    end update
end Mandelbrot

View.Set ("graphics:max;max")

type Data :
    record
        mag : real
        offsetX, offsetY : int
    end record

fcn getData () : Data
    var newData : Data

    put "Magnification: " ..
    get newData.mag

    put "Offset X: " ..
    get newData.offsetX

    put "Offset Y: " ..
    get newData.offsetY

    result newData
end getData

proc mandelbrotLoop (m : ^Mandelbrot)
    loop
        exit when not m -> update ()
    end loop
end mandelbrotLoop

proc main ()
    var data : Data
    var highX : int
    var lowX : int
    var highY : int
    var lowY : int

    var m : ^Mandelbrot
    new Mandelbrot, m

    loop
        data := getData ()

        highX := round (data.mag * 2) + data.offsetX
        lowX := -highX
        highY := round (data.mag * 2) + data.offsetY
        lowY := -highY

        m -> create (lowX, lowY, highX, highY, data.mag)
        cls
        mandelbrotLoop (m)
    end loop
end main
main ()

update ()

refresh ()

reload (x, y : int)