src/mapgen.py (a93b274) - voxels

mapgen.py

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 = 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):
                                b = 7 - u - abs(v)
                                for w in range(-b, b + 1):
                                    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

voxels

Move source to src/