mapgen.py (2dda016) - voxels

mapgen.py

from libs import *
import region

def smerp(ab, w):
    assert all([abs(x) < 2 for x in ab])
    for i in range(w.shape[0]):
        ab = [a + w[i] ** 2 * (3 - 2 * w[i]) * (b - a) for (a, b) in zip(ab[::2], ab[1::2])]
    return ab[0]

class MapGen:
    def __init__(self):
        self.grads = [{} for _ in range(4)]
        self.regions = {}

def fetch(self, pos, onclick=None):
        if pos in self.regions:
            return self.regions[pos]
        else:
            wr = region.WorldRegion()
            wr.pos = vec(pos)
            self.world_natural(wr)
            wr.remesh()
            if onclick:
                wr.onclick = lambda s, b, c: onclick(s, b, c, self)
            self.regions[pos] = wr
            return wr

def perlin(self, name, pos, period):
        dim = pos.shape[0]
        gt = self.grads[dim].setdefault(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.setdefault(ci, normalise(np.random.normal(size=dim)))
            assert abs(np.linalg.norm(cg) - 1) < 1e-3
            dots.append(np.dot(fract - c, cg))
        return 2 * smerp(dots, fract)

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, 5])) - wr.pos[1]
                for k in range(min(int(h), wr.r)):
                    wr.grid[i, k, j] = 3
                    n += 1
                if h > 0 and h < wr.r:
                    wr.grid[i, int(h), j] = 4
        return n

def world_min(self, wr):
        wr.set_voxel((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

voxels

Load multiple regions and fix colours