Generating realistic terrain data - Part 2

Question

I've made a "heightmap" terrain generator similar to my previous one, except this one has some improvements, and some new features.

The way this one works is similar to my last one, but slightly different, so I'll run through it again.

1. First, a list of NoneTypes is generated with a set width and height.
2. Next, the generator "seeds" certain areas in this list with random values between the minimum world height, and maximum world height.
3. After that, the generator iterates over this data a set amount of times, and determines neighbor tile values based on the height value of the current tile. It is determined like this: tile + randint(self.min_change, self.max_change).
4. After the generator is done iterating, it does one loop through the data and replaces any remaining NoneTypes with the minimum height value.
5. Finally, if smoothing=True, then the smoother iterates over the data once, and adjusts the values of neighbor tiles to make height distances "less extreme".

---

"""
A basic library containing a class for
generating basic terrain data.
"""
from random import randint


class Terrain(object):
    """
    Terrain object for storing and generating
    "realistic" looking terrain in an array.
    """
    def __init__(self, 
                 min_height, max_height, 
                 min_change, max_change, 
                 data_width, data_height, 
                 seeding_iterations, generation_iterations,
                 smoothing=True, replace_NoneTypes=True):
        self.min_height = min_height
        self.max_height = max_height
        self.min_change = min_change
        self.max_change = max_change
        self.data_width = data_width
        self.data_height = data_height
        self.seeding_iterations = seeding_iterations
        self.generation_iterations = generation_iterations
        self.smoothing = smoothing
        self.replace_NoneTypes = replace_NoneTypes
        self.world_data = None

    def _assert_arguments(self):
        """
        Assert the provided arguments to __init__ and
        make sure that they are valid.
        """
        assert self.max_height > self.min_height, "Maximum height must be larger than minimum height."
        assert self.max_change > self.min_change, "Maximum change must be larger than minimum change."
        assert self.data_width > 0, "Width must be greater than zero."
        assert self.data_height > 0, "Height must be greater than zero."
        assert self.seeding_iterations > 0, "Seeding iterations must be greater than zero."
        assert self.generation_iterations > 0, "Generation iterations must be greater than zero."

    def _generate_inital_terrain(self):
        """
        Initalizes the self.world_data array with a
        NoneType value.
        """
        self.world_data = [[
                None for _ in range(self.data_width)
            ] for _ in range(self.data_height)
        ]

    def _seed_terrain(self):
        """
        "Seeds" the terrain by choosing a random spot
        in self.world_data, and setting it to a random
        value between self.min_height and self.max_height.
        """
        for _ in range(self.seeding_iterations):
            random_x = randint(0, self.data_width - 1)
            random_y = randint(0, self.data_height - 1)
            self.world_data[random_x][random_y] = randint(
                self.min_height, self.max_height
            )

    def _generate_iterate(self):
        """
        Generates the terrain by iterating n times
        and iterating over the world data and changing
        terrain values based on tile values.
        """
        for _ in range(self.generation_iterations):
            for index_y, tile_row in enumerate(self.world_data):
                for index_x, tile in enumerate(tile_row):
                    upper_index = index_y + 1
                    lower_index = index_y - 1
                    right_index = index_x + 1
                    left_index = index_x - 1

                    if tile is not None:
                        upper_value = tile + randint(self.min_change, self.max_change)
                        lower_value = tile + randint(self.min_change, self.max_change)
                        right_value = tile + randint(self.min_change, self.max_change)
                        left_value = tile + randint(self.min_change, self.max_change)

                        try:
                            if self.min_height <= tile <= self.max_height:
                                self.world_data[upper_index][index_x] = upper_value
                                self.world_data[lower_index][index_x] = lower_value
                                self.world_data[index_y][right_index] = right_value
                                self.world_data[index_y][left_index] = left_value

                        except IndexError:
                            continue

    def _replace_NoneTypes(self):
        """ 
        Iterates over the world data one last time
        and replaces any remaining NoneType's with
        the minimum height value.
        """
        if self.replace_NoneTypes:
            for index_y, tile_row in enumerate(self.world_data):
                for index_x, tile in enumerate(tile_row):
                    if tile is None:
                        self.world_data[index_y][index_x] = self.min_height

    def _smooth_terrain(self):
        """ 
        "Smoothes" the terrain a into slightly more
        "realistic" landscape.
        """
        if self.smoothing:
            for index_y, tile_row in enumerate(self.world_data):
                for index_x, tile in enumerate(tile_row):
                    try:
                        upper_tile = self.world_data[index_y - 1][index_x]
                        lower_tile = self.world_data[index_y + 1][index_x]
                        right_tile = self.world_data[index_y][index_x + 1]
                        left_tile = self.world_data[index_y][index_x - 1]

                        if upper_tile - tile >= 3:
                            self.world_data[index_y - 1][index_x] -= abs(upper_tile - tile) + 1
                        if tile - upper_tile <= -3:
                            self.world_data[index_y - 1][index_x] += abs(tile - upper_tile) - 1

                        if lower_tile - tile >= 3:
                            self.world_data[index_y + 1][index_x] -= abs(lower_tile - tile) + 1
                        if tile - lower_tile <= -3:
                            self.world_data[index_y + 1][index_x] += abs(tile - lower_tile) - 1

                        if right_tile - tile >= 3:
                            self.world_data[index_y][index_x + 1] -= abs(right_tile - tile) + 1
                        if tile - right_tile <= -3:
                            self.world_data[index_y][index_x + 1] += abs(tile - right_tile) - 1

                        if left_tile - tile >= 3:
                            self.world_data[index_y][index_x - 1] -= abs(left_tile - tile) + 1
                        if tile - left_tile <= -3:
                            self.world_data[index_y][index_x - 1] += abs(tile - left_tile) - 1

                    except IndexError:
                        continue

    def generate_data(self):
        """ 
        Puts together all the functions required
        for generation into one container for running.
        """
        self._assert_arguments()
        self._generate_inital_terrain()
        self._seed_terrain()
        self._generate_iterate()
        self._replace_NoneTypes()
        self._smooth_terrain()

    def return_data(self):
        """ 
        Returns the world data as a list.
        """
        return self.world_data

    def debug_data(self):
        """ 
        Prints out the height values in self.world_data
        for debugging and visuals.
        """
        for tile_row in self.world_data:
            print ' '.join([str(height_value) for height_value in tile_row])

---

Here's an example of how this is used.

terr = Terrain(1, 8, -1, 1, 20, 20, 3, 10, smoothing=True)
terr.generate_data()
terr.debug_data()

Anyways, here are a few things, that if you want to answer, you can, that I'd like suggestions for.

• How can I make this faster? The larger the world size, the longer the generation time.
• What am I doing that is "un-pythonic"?
• Are there any issues that I missed?

Answer 1

• You can remove some nesting by returning early.
• There are other changes that could bring down memory usage, but in general using generators instead of creating full lists is beneficial (xrange below).
• List comprehensions as a single function argument can be used without the rectangular brackets, i.e. "".join(x for x in []).
• Multiplying a list is a bit more concise then the equivalent list comprehension ([None] * 4), but beware of sharing if you were to nest that ([[None] * 4] * 4 contains the same list four times). That was already mentioned in the first post/answer.
• I've added _map_tiles method to extract the shared "iterate over all map tiles" behaviour.
• The smoothing function is a bit weird in the sense that the two tests can easily be merged into a single case and an addition. I don't know if you wanted maybe a more complex behaviour there, but this is equivalent and less confusing.
• I'm also not fond of the IndexError handling, although I can see why this is easier, as you don't have to bother with generating only valid coordinates, even then the fact that you abort early and don't check each of the four cases individually is a bit frustrating to look at. This was as well mentioned in the first post/answer.
• Since you handle quite a lot of coordinates I'd maybe suggest that, if you were to continue on this, to introduce more abstractions on top of the nested list representation in order to handle both the [x][y] syntax, as well as indexing by coordinate pairs, i.e. [(x, y)], via a Map class (or so). That way you can simplify other code a lot, e.g. via generating a list of coordinates, zip with new values, then apply them all at once; basically it would facilitate a more functional approach. Same, for example, by generating the four coordinates around a tile in one call, returning [(x, y+1), ...].

All in all:

"""
A basic library containing a class for
generating basic terrain data.
"""
from random import randint


class Terrain(object):
    """
    Terrain object for storing and generating
    "realistic" looking terrain in an array.
    """
    def __init__(self,
                 min_height, max_height,
                 min_change, max_change,
                 data_width, data_height,
                 seeding_iterations, generation_iterations,
                 smoothing=True, replace_NoneTypes=True):
        self.min_height = min_height
        self.max_height = max_height
        self.min_change = min_change
        self.max_change = max_change
        self.data_width = data_width
        self.data_height = data_height
        self.seeding_iterations = seeding_iterations
        self.generation_iterations = generation_iterations
        self.smoothing = smoothing
        self.replace_NoneTypes = replace_NoneTypes
        self.world_data = None

    def _assert_arguments(self):
        """
        Assert the provided arguments to __init__ and
        make sure that they are valid.
        """
        assert self.max_height > self.min_height, "Maximum height must be larger than minimum height."
        assert self.max_change > self.min_change, "Maximum change must be larger than minimum change."
        assert self.data_width > 0, "Width must be greater than zero."
        assert self.data_height > 0, "Height must be greater than zero."
        assert self.seeding_iterations > 0, "Seeding iterations must be greater than zero."
        assert self.generation_iterations > 0, "Generation iterations must be greater than zero."

    def _generate_inital_terrain(self):
        """
        Initalizes the self.world_data array with a
        NoneType value.
        """
        self.world_data = [[None] * self.data_width
                           for _ in xrange(self.data_height)]

    def _seed_terrain(self):
        """
        "Seeds" the terrain by choosing a random spot
        in self.world_data, and setting it to a random
        value between self.min_height and self.max_height.
        """
        for _ in xrange(self.seeding_iterations):
            random_x = randint(0, self.data_width - 1)
            random_y = randint(0, self.data_height - 1)
            self.world_data[random_x][random_y] = randint(
                self.min_height, self.max_height
            )

    def _map_tiles(self, function):
        for index_y, tile_row in enumerate(self.world_data):
            for index_x, tile in enumerate(tile_row):
                function(index_y, tile_row, index_x, tile)

    def _generate_iterate(self):
        """
        Generates the terrain by iterating n times
        and iterating over the world data and changing
        terrain values based on tile values.
        """
        def generate_tile(index_y, tile_row, index_x, tile):
            if tile is None:
                return

            rand_values = [tile + randint(self.min_change,
                                          self.max_change)
                           for _ in xrange(4)]

            try:
                if self.min_height <= tile <= self.max_height:
                    self.world_data[index_y + 1][index_x] = rand_values[0]
                    self.world_data[index_y - 1][index_x] = rand_values[1]
                    self.world_data[index_y][index_x + 1] = rand_values[2]
                    self.world_data[index_y][index_x - 1] = rand_values[3]

            except IndexError:
                pass

        for _ in xrange(self.generation_iterations):
            self._map_tiles(generate_tile)

    def _replace_NoneTypes(self):
        """
        Iterates over the world data one last time
        and replaces any remaining NoneType's with
        the minimum height value.
        """
        def set_min_height(index_y, tile_row, index_x, tile):
            if tile is None:
                self.world_data[index_y][index_x] = self.min_height

        self._map_tiles(set_min_height)

    def _smooth_terrain(self):
        """
        "Smoothes" the terrain a into slightly more
        "realistic" landscape.
        """
        threshold = 3
        factor = 2

        def smooth_tile(index_y, tile_row, index_x, tile):
            def smooth_single(other_tile_y, other_tile_x):
                other_tile = self.world_data[other_tile_y][other_tile_x]

                if other_tile - tile >= threshold:
                    self.world_data[other_tile_y][other_tile_x] -= factor

            try:
                smooth_single(index_y - 1, index_x)
                smooth_single(index_y + 1, index_x)
                smooth_single(index_y, index_x + 1)
                smooth_single(index_y, index_x - 1)

            except IndexError:
                pass

        self._map_tiles(smooth_tile)

    def generate_data(self):
        """
        Puts together all the functions required
        for generation into one container for running.
        """
        self._assert_arguments()
        self._generate_inital_terrain()
        self._seed_terrain()
        self._generate_iterate()
        if self.replace_NoneTypes:
            self._replace_NoneTypes()
        if self.smoothing:
            self._smooth_terrain()

    def return_data(self):
        """
        Returns the world data as a list.
        """
        return self.world_data

    def debug_data(self):
        """
        Prints out the height values in self.world_data
        for debugging and visuals.
        """
        for tile_row in self.world_data:
            print ' '.join(str(height_value) for height_value in tile_row)


if __name__ == "__main__":
    terr = Terrain(1, 8, -1, 1, 20, 20, 3, 10, smoothing=True)
    terr.generate_data()
    terr.debug_data()