from libs import *
from collections import defaultdict
import world

class MapGen(world.WorldHolder):
    def __init__(self):
        super().__init__()
        self.grads = []
        for d in range(4):
            self.grads.append(defaultdict(lambda dim=d:
                defaultdict(lambda: normalise(np.random.normal(size=dim)))
            ))
        self.poissons = {}

    def perlin(self, name, pos, period):
        dim = pos.shape[0]
        gt = self.grads[dim][name]
        corner, fract = np.divmod(pos, period)
        fract /= period
        # https://stackoverflow.com/a/58827205
        corners = np.arange(1 << dim)[:, None] >> np.arange(dim) & 1
        dots = []
        for c in corners:
            ci = tuple(np.add(c, corner, dtype=int, casting="unsafe"))
            dots.append(np.dot(fract - c, gt[ci]))
        return 2 * smerp(dots, fract)

    def poisson(self, name, pos, r, period):
        dim = pos.shape[0]
        if name in self.poissons:
            gt = self.poissons[name]
        else:
            gt = defaultdict(lambda: np.random.poisson(
                1 / np.prod(period), np.repeat(r, dim)
            ))
            self.poissons[name] = gt
        return gt[tuple((x // r) * r for x in pos)]

    def world_natural(self, wr):
        n = 0
        for i in range(wr.r):
            for j in range(wr.r):
                h = np.astype(np.floor(4 + 4 * self.perlin(
                    "height",
                    np.add(wr.pos[[0, 2]], (i, j)),
                    np.array([10, 20])
                ) - wr.pos[1]), int)
                if h > 0:
                    wr.grid[i, :min(h, wr.r), j] = 3
                if h < wr.r and h >= 0:
                    wr.grid[i, h, j] = 4
                    inner = 2 <= i < wr.r - 2 and 2 <= j < wr.r - 2
                    if inner and self.poisson(
                            "trees", wr.pos[[0, 2]], wr.r, (6, 6)
                        )[i, j] >= 1:
                        for u in range(1, 6):
                            self.voxel_at(wr.pos + [i, h + u, j], 5)
                        for u in range(5, 7):
                            for v in range(-7 + u, 8 - u):
                                b = 7 - u - abs(v)
                                for w in range(-b, b + 1):
                                    self.voxel_at(
                                        wr.pos + [i + v, h + u, j + w], 6
                                    )
        return n

    def make_texture(self, name, dims, mid, offset, period):
        m, o = vec(mid), vec(offset)
        ta = np.empty(dims + (3,))
        for i in range(dims[1]):
            for j in range(dims[0]):
                ta[i, j] = m + o * self.perlin(name, vec((i, j)), period)
        return np.multiply(255, ta, dtype=FLOAT)