/*
                    xo_Perlin : Perlin Noise Generator
                  copyright ©2007 Andrew "Xooxer" Arnold
                           ~All Rights Reserved

////////////////////////////////////////////////////////////////////////////



xo_Perlin - The xo_Perlin datum. Use var/xo_Perlin/P = new(32, 32, 256)
            to create a new xo_Perlin datum called P with the width
            and height of 32, and seeded with the number 256.


    InitNoise(w, h, seed)
            You can also create a new null xo_Perlin datum, and set
            its dimensions later with InitNoise(). The following
            code produces the same effect as above.

                var/xo_Perlin/P = new()
                P.InitNoise(32, 32, 256)

            Seeding your noise is optional, and defaults to 0 (no seeding).


    GenNoise(seed)
            You may wish to reuse your noise datum, but alter the seed.
            Call this proceedure to re-generate your noise with the
            new seed.


    Perlin(turbulance)
            Returns a two-dimensional list containing the final rendered
            noise with the amount of turbulance stated (defaults to 64).


    Turbulance(x, y, turbulance)
            Use this procedure if you only need the final rendered noise for
            a single x,y coordinate within your noise array. Turbulance is
            optional, as above (defaults to 64).


    SmoothNoise(x,y)
            Used by this library to create the final noise rendering.



*/


xo_Perlin
    var
        width
        height
        list
            noise



    New(w, h, seed)
        ..()
        if(w || h)
            InitNoise(w, h, seed)



    proc
        InitNoise(w, h, seed)
            width = w
            height = h
            noise = noise[max(w,1)][max(h,1)]
            GenNoise(seed)


        GenNoise(seed)
            if(seed) rand_seed(seed)
            for(var/y = 1 to height)
                for(var/x = 1 to width)
                    noise[x][y] = rand()


        SmoothNoise(x, y)
            var
                fractX = x - round(x)
                fractY = y - round(y)

                x1 = max(round((round(x) + width) % width),1)
                y1 = max(round((round(y) + height) % height),1)

                x2 = max(round((x1 + width - 1) % width),1)
                y2 = max(round((y1 + height - 1) % height),1)

                value = 0
            value += fractX       * fractY       * noise[x1][y1]
            value += fractX       * (1 - fractY) * noise[x1][y2]
            value += (1 - fractX) * fractY       * noise[x2][y1]
            value += (1 - fractX) * (1 - fractY) * noise[x2][y2]

            return value


        Turbulance(x, y, turbulance=64)
            var
                value = 0
                initSize = turbulance

            while(turbulance>=1)
                value += SmoothNoise(width/turbulance, height/turbulance) * turbulance
                turbulance /= 2
            return (128.0 * value / initSize)


        Perlin(turbulance)
            var/n[width][height]
            for(var/y = 1 to height)
                for(var/x = 1 to width)
                    var/c = Turbulance(x, y, turbulance)
                    n[x][y] = c
            return n