Ejemplo n.º 1
0
 def test_perlin_noise_wrap(self):
     gen = perlin_noise.perlinNoiseGenerator()
     gen.wrap_x = 3
     gen.wrap_y = 3
     self.assertTrue(gen.noise2d(1,0)==gen.noise2d(1,3))
     self.assertAlmostEqual(gen.interpolate(1,0), gen.interpolate(1,3))
     self.assertAlmostEqual(gen.interpolate(1.5,0), gen.interpolate(1.5,3))
Ejemplo n.º 2
0
 def test_perlin_noise_wrap(self):
     gen = perlin_noise.perlinNoiseGenerator()
     gen.wrap_x = 3
     gen.wrap_y = 3
     self.assertTrue(gen.noise2d(1, 0) == gen.noise2d(1, 3))
     self.assertAlmostEqual(gen.interpolate(1, 0), gen.interpolate(1, 3))
     self.assertAlmostEqual(gen.interpolate(1.5, 0),
                            gen.interpolate(1.5, 3))
Ejemplo n.º 3
0
    def buildPerlinNoiseGenerator(self, smoothness) -> perlin_noise.perlinNoiseGenerator:
        """
        Creates a perlin noise generator fitting the requirements of this world map.
        """
        grid_size_x = self.max_x/smoothness
        grid_size_y = self.max_y/smoothness
        if (grid_size_x < 1):
            grid_size_x = 1
        if (grid_size_y < 1):
            grid_size_y = 1

        gen = perlin_noise.perlinNoiseGenerator()
        gen.wrap_x = grid_size_x
        gen.wrap_y = grid_size_y
        return gen
Ejemplo n.º 4
0
    def buildPerlinNoiseGenerator(
            self, smoothness) -> perlin_noise.perlinNoiseGenerator:
        """
        Creates a perlin noise generator fitting the requirements of this world map.
        """
        grid_size_x = self.max_x / smoothness
        grid_size_y = self.max_y / smoothness
        if (grid_size_x < 1):
            grid_size_x = 1
        if (grid_size_y < 1):
            grid_size_y = 1

        gen = perlin_noise.perlinNoiseGenerator()
        gen.wrap_x = grid_size_x
        gen.wrap_y = grid_size_y
        return gen
Ejemplo n.º 5
0
    def test_perlin_noise(self):
        gen = perlin_noise.perlinNoiseGenerator()
        a = gen.noise2d(2, 3)
        b = gen.noise2d(2, 3)

        c = gen.noise2d(3, 2)
        self.assertTrue(a == b)
        self.assertTrue(a != c)

        gen2 = mockPerlinNoise()
        self.assertTrue(gen2.noise2d(3, 3) != gen.noise2d(3, 3))
        point = 1, 1.4

        this_one = gen.interpolate(*point)
        that_one = gen.interpolate(*point)

        a_different_one = gen.interpolate(30, 8.3)
        self.assertTrue(this_one == that_one)
        self.assertTrue(this_one != a_different_one)

        a_mid_point = 30.5, 30.5
        x, y = a_mid_point
        a = math.floor(x), math.floor(y)
        b = math.floor(x), math.ceil(y)
        c = math.ceil(x), math.floor(y)
        d = math.ceil(x), math.ceil(y)

        outer_points = a, b, c, d
        noise = [gen.noise2d(x, y) for x, y in outer_points]
        average = sum(noise) / float(len(noise))
        calculated = gen.interpolate(30.5, 30.5)
        #Algorithm requires that a point midway between all nearest vertices have a height equal to that
        #of all points.
        self.assertTrue(math.fabs(average - calculated) < 0.001)

        rounded_point = 30, 30
        #Checks that the noise generated for that point is the same as the interpolated value for that point.
        self.assertTrue(
            gen.interpolate(*rounded_point) == gen.noise2d(*rounded_point))
Ejemplo n.º 6
0
    def test_perlin_noise(self):
        gen = perlin_noise.perlinNoiseGenerator()
        a = gen.noise2d(2,3)
        b = gen.noise2d(2,3)

        c = gen.noise2d(3,2)
        self.assertTrue(a==b)
        self.assertTrue(a!=c)

        gen2 = mockPerlinNoise()
        self.assertTrue(gen2.noise2d(3,3) != gen.noise2d(3,3))
        point = 1,1.4

        this_one = gen.interpolate(*point)
        that_one = gen.interpolate(*point)

        a_different_one = gen.interpolate(30,8.3)
        self.assertTrue(this_one == that_one)
        self.assertTrue(this_one != a_different_one)

        a_mid_point = 30.5,30.5
        x,y=a_mid_point
        a = math.floor(x),math.floor(y)
        b = math.floor(x),math.ceil(y)
        c = math.ceil(x), math.floor(y)
        d = math.ceil(x), math.ceil(y)

        outer_points = a,b,c,d
        noise = [gen.noise2d(x,y) for x,y in outer_points]
        average = sum(noise)/float(len(noise))
        calculated = gen.interpolate(30.5,30.5)
        #Algorithm requires that a point midway between all nearest vertices have a height equal to that
        #of all points.
        self.assertTrue(math.fabs(average - calculated) < 0.001)

        rounded_point = 30,30
        #Checks that the noise generated for that point is the same as the interpolated value for that point.
        self.assertTrue(gen.interpolate(*rounded_point) == gen.noise2d(*rounded_point))