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 ()  |