from libs import *
from collections import defaultdict
import world

class MapGen(world.WorldHolder):
    def __init__(self):
        super().__init__()
        self.grads = [defaultdict(lambda dim=d: defaultdict(lambda: normalise(np.random.normal(size=dim)))) for d in range(4)]
        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"))
            cg = gt[ci]
            assert abs(np.linalg.norm(cg) - 1) < 1e-3
            dots.append(np.dot(fract - c, cg))
        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 = 4 + 4 * self.perlin("height", np.add(wr.pos[[0, 2]], (i, j)), np.array([10, 20])) - wr.pos[1]
                if h > 0:
                    wr.grid[i, :min(int(h), wr.r), j] = 3
                if h < wr.r and h > 0:
                    wr.grid[i, int(h), j] = 4
                    if 2 <= i < wr.r - 2 and 2 <= j < wr.r - 2 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 + [0, h + u, 0], 5)
                        for u in range(5, 7):
                            for v in range(-7 + u, 8 - u):
                                for w in range(-7 + u + abs(v), 8 - u - abs(v)):
                                    self.voxel_at(wr.pos + [v, h + u, w], 6)
        return n

    def world_min(self, wr):
        wr.grid[0, 0, 0] = 1
        return 1

    def world_grid(self, wr):
        n = 0
        for i in range(0, wr.r, 2):
            for j in range(0, wr.r, 2):
                for k in range(0, wr.r, 2):
                    wr.grid[i, j, k] = 1
                    n += 1
        return n

    def world_checker(self, wr):
        n = 0
        for i in range(wr.r):
            for j in range(wr.r):
                for k in range(wr.r):
                    if not (i + j + k) % 2:
                        wr.grid[i, j, k] = 1
                        n += 1
        return n