コード例 #1
0
ファイル: test_edge.py プロジェクト: sl4ker/hexgen
    def setUp(self):
        params = default_params
        self.size = 50
        params['size'] = self.size
        self.heightmap = Heightmap(params)

        self.grid = Grid(self.heightmap, params)

        self.h1 = self.grid.find_hex(0, 0)
        self.h4 = self.grid.find_hex(1, 0)
        self.h9 = self.grid.find_hex(2, 2)
        self.e1 = self.h1.edge_south_east
        self.e2 = self.h4.edge_north_west
        self.e3 = self.h9.edge_north_west
コード例 #2
0
ファイル: test_edge.py プロジェクト: sl4ker/hexgen
class TestEdge(TestCase):
    def setUp(self):
        params = default_params
        self.size = 50
        params['size'] = self.size
        self.heightmap = Heightmap(params)

        self.grid = Grid(self.heightmap, params)

        self.h1 = self.grid.find_hex(0, 0)
        self.h4 = self.grid.find_hex(1, 0)
        self.h9 = self.grid.find_hex(2, 2)
        self.e1 = self.h1.edge_south_east
        self.e2 = self.h4.edge_north_west
        self.e3 = self.h9.edge_north_west

    def test_calculate(self):
        self.assertTrue(isinstance(self.e1, Edge),
                        "e1 is not an Edge, calculate() "
                        "may not be working")

    def test_sides(self):
        self.assertTrue(self.e1.side == HexSide.south_east,
                        "Edge has wrong HexSide enum")

    def test_init(self):
        self.assertTrue(
            self.e1.one == self.h1,
            "'one' value for Hex 1 Edge 1 is not Hex 1, was {}".format(
                self.e1.one))
        self.assertTrue(
            self.e1.two == self.h4,
            "'two' value for Hex 2 Edge 1 is not Hex 4, was {}".format(
                self.e1.two))

    def test_equality(self):
        """ Tests that the __eq__ function is working correctly """
        self.assertTrue(self.e1 == self.e1, "E1 equals E1")
        self.assertTrue(
            self.e1 == self.e2,
            "Hex 1 Edge SE and Hex 4 Edge NW should be equal, was \n{}\n{}".
            format(self.e1, self.e2))
        self.assertFalse(
            self.e1 == self.e3,
            "Hex 1 Edge SE and Hex 9 Edge NW should not be equal")
コード例 #3
0
ファイル: test_edge.py プロジェクト: BinaryTiger/hexgen
    def setUp(self):
        params = default_params
        self.size = 50
        params['size'] = self.size
        self.heightmap = Heightmap(params)

        self.grid = Grid(self.heightmap, params)

        self.h1 = self.grid.find_hex(0, 0)
        self.h4 = self.grid.find_hex(1, 0)
        self.h9 = self.grid.find_hex(2, 2)
        self.e1 = self.h1.edge_south_east
        self.e2 = self.h4.edge_north_west
        self.e3 = self.h9.edge_north_west
コード例 #4
0
ファイル: test_edge.py プロジェクト: BinaryTiger/hexgen
class TestEdge(TestCase):

    def setUp(self):
        params = default_params
        self.size = 50
        params['size'] = self.size
        self.heightmap = Heightmap(params)

        self.grid = Grid(self.heightmap, params)

        self.h1 = self.grid.find_hex(0, 0)
        self.h4 = self.grid.find_hex(1, 0)
        self.h9 = self.grid.find_hex(2, 2)
        self.e1 = self.h1.edge_south_east
        self.e2 = self.h4.edge_north_west
        self.e3 = self.h9.edge_north_west

    def test_calculate(self):
        self.assertTrue(isinstance(self.e1, Edge), "e1 is not an Edge, calculate() "
                                                   "may not be working")

    def test_sides(self):
        self.assertTrue(self.e1.side == HexSide.south_east, "Edge has wrong HexSide enum")

    def test_init(self):
        self.assertTrue(self.e1.one == self.h1,
                        "'one' value for Hex 1 Edge 1 is not Hex 1, was {}".format(self.e1.one))
        self.assertTrue(self.e1.two == self.h4,
                        "'two' value for Hex 2 Edge 1 is not Hex 4, was {}".format(self.e1.two))

    def test_equality(self):
        """ Tests that the __eq__ function is working correctly """
        self.assertTrue(self.e1 == self.e1, "E1 equals E1")
        self.assertTrue(self.e1 == self.e2,
                        "Hex 1 Edge SE and Hex 4 Edge NW should be equal, was \n{}\n{}"
                        .format(self.e1, self.e2))
        self.assertFalse(self.e1 == self.e3, "Hex 1 Edge SE and Hex 9 Edge NW should not be equal")
コード例 #5
0
ファイル: mapgen.py プロジェクト: BinaryTiger/hexgen
    def __init__(self, params, debug=False):
        """ initialize """
        self.params = default_params
        self.params.update(params)

        if debug:
            print("Making world with params:")
            for key, value in params.items():
                print("\t{}:\t{}".format(key, value))

        self.debug = debug

        if type(params.get("random_seed")) is int:
            random.seed(params.get("random_seed"))

        self.heightmap = Heightmap(self.params)

        self.hex_grid = Grid(self.heightmap, self.params)

        self.rivers = []
        self.rivers_sources = []

        print("Computing hex distances") if self.debug else False
        self._get_distances()

        if self.params.get("hydrosphere"):
            self._generate_rivers()

            # give coastal land hexes moisture based on how close to the coast they are
            print("Making coastal moisture") if self.debug else False
            for y, row in enumerate(self.hex_grid.grid):
                for x, col in enumerate(row):
                    hex = self.hex_grid.grid[x][y]
                    if hex.is_land:
                        if hex.distance <= 5:
                            hex.moisture += 1
                        if hex.distance <= 3:
                            hex.moisture += random.randint(1, 3)
                        if hex.distance <= 1:
                            hex.moisture += random.randint(1, 6)

        # generate aquifers
        num_aquifers = random.randint(5, 25)

        if self.params.get("hydrosphere") is False or self.params.get("sea_percent") == 100:
            num_aquifers = 0

        print("Making {} aquifers".format(num_aquifers)) if self.debug else False
        aquifers = []
        while len(aquifers) < num_aquifers:
            rx = random.randint(0, len(self.hex_grid.grid) - 1)
            ry = random.randint(0, len(self.hex_grid.grid) - 1)
            hex = self.hex_grid.grid[rx][ry]
            if hex.is_land and hex.moisture < 5:
                aquifers.append(hex)

        for hex in aquifers:
            # print("Aquifer at ", hex)
            r1 = hex.bubble(distance=3)
            for hex in r1:
                if hex.is_land:
                    hex.moisture += random.randint(0, 2)
            r2 = hex.bubble(distance=2)
            for hex in r2:
                if hex.is_land:
                    hex.moisture += 1
            r3 = hex.surrounding
            for hex in r3:
                if hex.is_land:
                    hex.moisture += 1

        # decide terrain features
        print("Making terrain features") if self.debug else False
        # craters only form in barren planets with a normal or lower atmosphere
        if self.params.get("craters") is True:

            # decide number of craters
            num_craters = random.randint(0, 15)
            print("Making {} craters".format(num_craters))
            craters = []

            while len(craters) < num_craters:
                size = random.randint(1, 3)
                craters.append(dict(hex=random.choice(self.hex_grid.hexes), size=size, depth=10 * size))

            for crater in craters:

                center_hex = crater.get("hex")
                size = crater.get("size")
                depth = crater.get("depth")
                hexes = []

                if size >= 1:
                    hexes = center_hex.surrounding
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 5
                        h.altitude = max(h.altitude, 0)
                if size >= 2:
                    hexes = center_hex.bubble(distance=2)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 10
                        h.altitude = max(h.altitude, 0)

                if size >= 3:
                    hexes = center_hex.bubble(distance=3)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 15
                        h.altitude = max(h.altitude, 0)
                for h in hexes[: round(len(hexes) / 3)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.crater) is False:
                            i.add_feature(HexFeature.crater)
                            i.altitude = center_hex.altitude - 20
                            i.altitude = max(i.altitude, 0)

        # volcanoes
        if self.params.get("volcanoes"):

            num_volcanoes = random.randint(0, 10)
            print("Making {} volcanoes".format(num_volcanoes))
            volcanoes = []
            while len(volcanoes) < num_volcanoes:
                center_hex = random.choice(self.hex_grid.hexes)
                if center_hex.altitude > 50:
                    size = random.randint(1, 5)
                    height = random.randint(30, 70)
                    volcanoes.append(dict(hex=center_hex, size=size, height=height))

            for volcano in volcanoes:
                height = volcano.get("height")
                size = volcano.get("size")
                center_hex = volcano.get("hex")
                print("\tVolcano: Size: {}, Height: {}".format(size, height))
                size_list = list(range(size))
                size_list.reverse()
                hexes = []
                for i in size_list:
                    i += 1
                    this_height = round(height / i)
                    if i == 1:
                        l = center_hex.surrounding + [center_hex]
                    else:
                        l = center_hex.bubble(distance=i)
                    for h in l:
                        hexes.append(h)
                        h.altitude = center_hex.altitude + this_height
                        h.add_feature(HexFeature.volcano)

                last_altitude = 0
                for h in hexes[: round(len(hexes) / 2)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.volcano) is False:
                            i.add_feature(HexFeature.volcano)
                            i.altitude += 5
                            i.altitude = min(i.altitude, 255)
                            last_altitude = i.altitude
                center_hex.altitude += last_altitude + 5

                # lava flow
                def step(active_hex):
                    if active_hex.altitude < 50:
                        return
                    else:
                        active_hex.add_feature(HexFeature.lava_flow)
                        found = []
                        for i in active_hex.surrounding:
                            if i.altitude <= active_hex.altitude and i.has_feature(HexFeature.lava_flow) is False:
                                found.append(i)
                        found.sort(key=lambda x: x.altitude)
                        if len(found) > 1:
                            step(found[0])
                        if len(found) > 2:
                            step(found[1])

                step(center_hex)

        self.territories = []
        self.generate_territories()
        self.generate_resources()

        print("Done") if self.debug else False
コード例 #6
0
ファイル: mapgen.py プロジェクト: BinaryTiger/hexgen
class MapGen:
    """ generates a heightmap as an array of integers between 1 and 255
    using the diamond-square algorithm"""

    def __init__(self, params, debug=False):
        """ initialize """
        self.params = default_params
        self.params.update(params)

        if debug:
            print("Making world with params:")
            for key, value in params.items():
                print("\t{}:\t{}".format(key, value))

        self.debug = debug

        if type(params.get("random_seed")) is int:
            random.seed(params.get("random_seed"))

        self.heightmap = Heightmap(self.params)

        self.hex_grid = Grid(self.heightmap, self.params)

        self.rivers = []
        self.rivers_sources = []

        print("Computing hex distances") if self.debug else False
        self._get_distances()

        if self.params.get("hydrosphere"):
            self._generate_rivers()

            # give coastal land hexes moisture based on how close to the coast they are
            print("Making coastal moisture") if self.debug else False
            for y, row in enumerate(self.hex_grid.grid):
                for x, col in enumerate(row):
                    hex = self.hex_grid.grid[x][y]
                    if hex.is_land:
                        if hex.distance <= 5:
                            hex.moisture += 1
                        if hex.distance <= 3:
                            hex.moisture += random.randint(1, 3)
                        if hex.distance <= 1:
                            hex.moisture += random.randint(1, 6)

        # generate aquifers
        num_aquifers = random.randint(5, 25)

        if self.params.get("hydrosphere") is False or self.params.get("sea_percent") == 100:
            num_aquifers = 0

        print("Making {} aquifers".format(num_aquifers)) if self.debug else False
        aquifers = []
        while len(aquifers) < num_aquifers:
            rx = random.randint(0, len(self.hex_grid.grid) - 1)
            ry = random.randint(0, len(self.hex_grid.grid) - 1)
            hex = self.hex_grid.grid[rx][ry]
            if hex.is_land and hex.moisture < 5:
                aquifers.append(hex)

        for hex in aquifers:
            # print("Aquifer at ", hex)
            r1 = hex.bubble(distance=3)
            for hex in r1:
                if hex.is_land:
                    hex.moisture += random.randint(0, 2)
            r2 = hex.bubble(distance=2)
            for hex in r2:
                if hex.is_land:
                    hex.moisture += 1
            r3 = hex.surrounding
            for hex in r3:
                if hex.is_land:
                    hex.moisture += 1

        # decide terrain features
        print("Making terrain features") if self.debug else False
        # craters only form in barren planets with a normal or lower atmosphere
        if self.params.get("craters") is True:

            # decide number of craters
            num_craters = random.randint(0, 15)
            print("Making {} craters".format(num_craters))
            craters = []

            while len(craters) < num_craters:
                size = random.randint(1, 3)
                craters.append(dict(hex=random.choice(self.hex_grid.hexes), size=size, depth=10 * size))

            for crater in craters:

                center_hex = crater.get("hex")
                size = crater.get("size")
                depth = crater.get("depth")
                hexes = []

                if size >= 1:
                    hexes = center_hex.surrounding
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 5
                        h.altitude = max(h.altitude, 0)
                if size >= 2:
                    hexes = center_hex.bubble(distance=2)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 10
                        h.altitude = max(h.altitude, 0)

                if size >= 3:
                    hexes = center_hex.bubble(distance=3)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 15
                        h.altitude = max(h.altitude, 0)
                for h in hexes[: round(len(hexes) / 3)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.crater) is False:
                            i.add_feature(HexFeature.crater)
                            i.altitude = center_hex.altitude - 20
                            i.altitude = max(i.altitude, 0)

        # volcanoes
        if self.params.get("volcanoes"):

            num_volcanoes = random.randint(0, 10)
            print("Making {} volcanoes".format(num_volcanoes))
            volcanoes = []
            while len(volcanoes) < num_volcanoes:
                center_hex = random.choice(self.hex_grid.hexes)
                if center_hex.altitude > 50:
                    size = random.randint(1, 5)
                    height = random.randint(30, 70)
                    volcanoes.append(dict(hex=center_hex, size=size, height=height))

            for volcano in volcanoes:
                height = volcano.get("height")
                size = volcano.get("size")
                center_hex = volcano.get("hex")
                print("\tVolcano: Size: {}, Height: {}".format(size, height))
                size_list = list(range(size))
                size_list.reverse()
                hexes = []
                for i in size_list:
                    i += 1
                    this_height = round(height / i)
                    if i == 1:
                        l = center_hex.surrounding + [center_hex]
                    else:
                        l = center_hex.bubble(distance=i)
                    for h in l:
                        hexes.append(h)
                        h.altitude = center_hex.altitude + this_height
                        h.add_feature(HexFeature.volcano)

                last_altitude = 0
                for h in hexes[: round(len(hexes) / 2)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.volcano) is False:
                            i.add_feature(HexFeature.volcano)
                            i.altitude += 5
                            i.altitude = min(i.altitude, 255)
                            last_altitude = i.altitude
                center_hex.altitude += last_altitude + 5

                # lava flow
                def step(active_hex):
                    if active_hex.altitude < 50:
                        return
                    else:
                        active_hex.add_feature(HexFeature.lava_flow)
                        found = []
                        for i in active_hex.surrounding:
                            if i.altitude <= active_hex.altitude and i.has_feature(HexFeature.lava_flow) is False:
                                found.append(i)
                        found.sort(key=lambda x: x.altitude)
                        if len(found) > 1:
                            step(found[0])
                        if len(found) > 2:
                            step(found[1])

                step(center_hex)

        self.territories = []
        self.generate_territories()
        self.generate_resources()

        print("Done") if self.debug else False

    def generate_resources(self):
        print("Placing resources")
        ratings = HexResourceRating.list()
        types = HexResourceType.list()

        combined = []

        for r in ratings:
            for t in types:
                combined.append(dict(rating=r, type=t))
        for h in self.hex_grid.hexes:
            for resource in combined:
                chance = (resource.get("rating").rarity * resource.get("type").rarity * self.hex_grid.size / 1000) / (
                    math.pow(self.hex_grid.size, 2)
                )
                given = random.uniform(0, 1)
                if given <= chance:
                    h.resource = resource

    def generate_territories(self):
        """
         Makes territories
        """
        # select number of territories to place
        land_percent = 100 - self.params.get("sea_percent")
        num_territories = self.params.get("num_territories")

        # give each a land pixel to start
        print("Making {} territories".format(num_territories)) if self.debug else False

        c = 0
        if num_territories == 0:
            return
        while len(self.territories) < num_territories:
            rx = random.randint(0, len(self.hex_grid.grid) - 1)
            ry = random.randint(0, len(self.hex_grid.grid) - 1)
            hex_s = self.hex_grid.grid[rx][ry]
            if hex_s.is_land:
                color = random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)
                self.territories.append(Territory(self.hex_grid, hex_s, c, color))
                c += 1

        # loop over each, adding hexes
        total_hexes = self.hex_grid.size * self.hex_grid.size
        count = 0
        while count < total_hexes:  #  i in range(0, 15):
            count = 0
            # print("Start: {} < {}".format(count, total_hexes))
            territories = self.territories
            random.shuffle(territories)
            for t in territories:
                frontier = t.frontier
                for f in frontier:
                    if f.is_owned is False:
                        f.territory = t
                        t.members.append(f)
                        t.last_added.append(f)
                count += t.size
            # print("End: {} < {}".format(count, total_hexes))

        # remove water hexes
        for t in self.territories:
            members = t.members
            t.members = [h for h in t.members if h.is_land]
            water_hexes = (h for h in members if h.is_water)
            for h in water_hexes:
                h.territory = None

        # merge territories
        print("Merging barren territories")

        if self.params.get("num_territories") > 0:
            top = []
            bottom = []
            for t in self.territories:
                avg_x = round(sum([i.x for i in t.members]) / len(t.members))
                if t.avg_temp < 0 and (avg_x / self.hex_grid.size) < 0.5:
                    top.append(t)
                elif t.avg_temp < 0 and (avg_x / self.hex_grid.size) >= 0.5:
                    bottom.append(t)

            pick_top = None
            pick_bottom = None
            if len(top) > 0:
                print("Merging {} territories from the top of the map".format(len(top)))
                pick_top = random.choice(top)
                top.remove(pick_top)
                for t in self.territories:
                    if t in top:
                        pick_top.members += t.members
                        t.members = []

            if len(bottom) > 0:
                print("Merging {} territories from the bottom of the map".format(len(bottom)))
                pick_bottom = random.choice(bottom)
                bottom.remove(pick_bottom)
                for t in self.territories:
                    if t in bottom:
                        pick_bottom.members += t.members
                        t.members = []

            if len(top) > 0:
                for h in pick_top.members:
                    h.territory = pick_top

            if len(bottom) > 0:
                for h in pick_bottom.members:
                    h.territory = pick_bottom

            self.territories = [t for t in self.territories if t is not None]

            print(
                "{} empty territories being deleted".format(len([t for t in self.territories if len(t.members) == 0]))
            )
            self.territories = [t for t in self.territories if len(t.members) > 0]

            print("There are now {} territories".format(len(self.territories)))

        print("Splitting territories into contiguous blocks") if self.debug else False
        for t in self.territories:
            t.find_groups()

    def _get_distances(self):
        """
        Gets the distances each land pixel is to the coastline.
        TODO: Make this more efficient
        """

        if not self.params.get("hydrosphere"):
            # we don't care about distances otherwise
            return

        for y, row in enumerate(self.hex_grid.grid):
            for x, col in enumerate(row):
                h = self.hex_grid.grid[x][y]
                if h.is_land:
                    count = 1
                    numbers = []

                    east = h.hex_east
                    while east.is_land is True and count < self.hex_grid.size * 2:
                        east = east.hex_east
                        count += 1
                    numbers.append(count)
                    count = 1

                    west = h.hex_west
                    while west.is_land is True and count < self.hex_grid.size * 2:
                        west = west.hex_west
                        count += 1
                    numbers.append(count)
                    count = 1

                    north_east = h.hex_north_east
                    while north_east.is_land is True and count < self.hex_grid.size * 2:
                        north_east = north_east.hex_north_east
                        count += 1
                    numbers.append(count)
                    count = 1

                    north_west = h.hex_north_west
                    while north_west.is_land is True and count < self.hex_grid.size * 2:
                        north_west = north_west.hex_north_west
                        count += 1

                    numbers.append(count)
                    count = 1

                    south_west = h.hex_south_west
                    while south_west.is_land is True and count < self.hex_grid.size * 2:
                        south_west = south_west.hex_south_west
                        count += 1
                    numbers.append(count)
                    count = 1

                    south_east = h.hex_south_east
                    while south_east.is_land is True and count < self.hex_grid.size * 2:
                        south_east = south_east.hex_south_east
                        count += 1
                    numbers.append(count)

                    h.distance = min(numbers)

    def _generate_rivers(self):
        """
        For each river source edge:
            If the "down" hex of the left edge is the "one" or "two" hexes of this edge,
                the left edge is invalid
            If the "down" hex of the right edge is the "one" or "two" hexes of this edge,
                the right edge is invalid
            If two are valid:
                E = lowest slope edge
                If E.down is below sea level, end here
                otherwise add this edge as a river segment
            else if one is valid:
                E = valid edge
                If E.down is below sea level, end here
                otherwise add this edge as a river segment
            else if both are invalid:
                Make a lake at the lowest of the "one" or "two" hexes of this edge
                Make a new river source edge at an random edge pointing out from this lake
                    that has a direction pointing out from the lake
        """
        land_percent = 100 - self.params.get("sea_percent")
        num_rivers = self.params.get("num_rivers")
        print("Making {} rivers".format(num_rivers)) if self.debug else False

        while len(self.rivers_sources) < num_rivers:
            rx = random.randint(0, self.hex_grid.size - 1)
            ry = random.randint(0, self.hex_grid.size - 1)
            hex_s = self.hex_grid.find_hex(rx, ry)
            if hex_s.is_inland and hex_s.altitude > self.hex_grid.sealevel + 35:
                if hex_s.temperature < 0:
                    # don't place rivers above +35 altitude when the temperature is below zero
                    continue
                random_side = random.choice(list(HexSide))
                # print("Placing river source at {}, {}".format(rx, ry))
                self.rivers_sources.append(RiverSegment(self.hex_grid, rx, ry, random_side, True))

        print("Placed river sources") if self.debug else False

        for r in self.rivers_sources:  # loop over each source segment
            segment = r  # river segment we are looking at
            finished = False
            last_unselected = None
            # we stop only when one of two things happen:
            #   - a lake is formed
            #   - we reached sea level
            while finished is False:
                # print("Segment: {}, {}".format(segment.x, segment.y))
                side_one, side_two = segment.side.branching(segment.edge.direction)
                down = segment.edge.down  # down-slope hex of this segment

                # add the moisture to the one and two hexes in a 3 radius
                one = segment.edge.one.bubble(distance=3)
                two = segment.edge.two.bubble(distance=3)
                both = list(set(one + two))
                for hex in both:
                    if hex.is_land:
                        hex.moisture += 1
                three = segment.edge.one.surrounding
                four = segment.edge.two.surrounding
                both = list(set(three + four))
                for hex in both:
                    if hex.is_land:
                        hex.moisture += 1

                # find the two Edges from the sides found branching
                edge_one = down.get_edge(side_one)
                edge_two = down.get_edge(side_two)

                # check if either of the edges are valid river segment locations
                one_valid = True
                two_valid = True
                if edge_one.down == segment.edge.one or edge_one.down == segment.edge.two:
                    one_valid = False
                if edge_two.down == segment.edge.one or edge_two.down == segment.edge.two:
                    two_valid = False

                if self.is_river(edge_one):
                    one_valid = False
                elif self.is_river(edge_two):
                    two_valid = False

                if one_valid and two_valid:
                    # print("\tBoth are valid edges")
                    if edge_one.down.altitude < edge_two.down.altitude:
                        selected = edge_one
                        selected_side = side_one
                        last_unselected = edge_two, side_two
                    else:
                        selected = edge_two
                        selected_side = side_two
                        last_unselected = edge_one, side_one
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x, selected.one.y, selected_side, False)
                    segment = segment.next
                elif one_valid is True and two_valid is False:
                    # print("\tOne is Valid")
                    selected = edge_one
                    last_unselected = edge_two, side_two
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x, selected.one.y, side_one, False)
                    segment = segment.next
                elif one_valid is False and two_valid is True:
                    # print("\tTwo is valid")
                    selected = edge_two
                    last_unselected = edge_one, side_one
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x, selected.one.y, side_two, False)
                    segment = segment.next
                else:
                    # import ipdb; ipdb.set_trace()
                    # segment.x = last_unselected[0].one.x
                    # segment.y = last_unselected[0].one.y
                    # segment.side = last_unselected[1]
                    # segment.is_source = True
                    # finished = True
                    # print("huh?")

                    # both edges are invalid, make lake at one or two
                    if segment.edge.one.altitude < segment.edge.two.altitude:
                        lake = segment.edge.one
                    else:
                        lake = segment.edge.two
                    lake.add_feature(HexFeature.lake)

                    # moisture around lake increases
                    surrounding = lake.surrounding
                    for hex in surrounding:
                        if hex.is_land:
                            hex.moisture += 3

                    # print("\tMade a lake at {}, {}".format(segment.x, segment.y))
                    #
                    # # make a new source river at an outer edge of the lake
                    # chosen_edge = random.choice(lake.outer_edges)
                    # self.rivers_sources.append(RiverSegment(self.hex_grid, chosen_edge.one.x, chosen_edge.one.y, chosen_edge.side, True))
                    finished = True

        final = []

        for r in self.rivers_sources:
            # remove rivers that are too small
            if r.size > 2:
                final.append(r)
                while r.next is not None:
                    # print("Segment: ", r.next)
                    final.append(r.next)
                    r = r.next
        self.rivers = final

    def is_river(self, edge):
        """
        Determines if an edge has a river
        :param edge: Edge
        :return: Boolean
        """
        for r in self.rivers_sources:
            while r.next is not None:
                if r.edge == edge:
                    return True
                r = r.next
        return False

    def find_river(self, x, y):
        """ Finds river segments at an hex's x and y coordinates. Returns a list of EdgeSides
            representing where the river segments are """
        seg = []
        for s in self.rivers:
            if s.x == x and s.y == y:
                seg.append(s.side)
        return seg
コード例 #7
0
    def __init__(self, params, debug=False):
        """ initialize """
        self.params = default_params
        self.params.update(params)

        if debug:
            print("Making world with params:")
            for key, value in params.items():
                print("\t{}:\t{}".format(key, value))

        self.debug = debug

        if type(params.get('random_seed')) is int:
            random.seed(params.get('random_seed'))

        with Timer("Building Heightmap", self.debug):
            self.heightmap = Heightmap(self.params, self.debug)

        self.hex_grid = Grid(self.heightmap, self.params)
        if self.debug is True:
            print("\tAverage Height: {}".format(self.hex_grid.average_height))
            print("\tHighest Height: {}".format(self.hex_grid.highest_height))
            print("\tLowest Height: {}".format(self.hex_grid.lowest_height))

        print("Making calendar")
        self.calendar = Calendar(self.params.get('year_length'),
                                 self.params.get('day_length'))

        self.rivers = []
        self.rivers_sources = []

        with Timer("Computing hex distances", self.debug):
            self._get_distances()

        self._generate_pressure()

        if self.params.get('hydrosphere'):
            self._generate_rivers()

            # give coastal land hexes moisture based on how close to the coast they are
            # TODO: replace with more realistic model
            print("Making coastal moisture") if self.debug else False
            for y, row in enumerate(self.hex_grid.grid):
                for x, col in enumerate(row):
                    hex = self.hex_grid.grid[x][y]
                    if hex.is_land:
                        if hex.distance <= 5:
                            hex.moisture += 1
                        if hex.distance <= 3:
                            hex.moisture += random.randint(1, 3)
                        if hex.distance <= 1:
                            hex.moisture += random.randint(1, 6)

        # generate aquifers
        num_aquifers = random.randint(5, 25)

        if self.params.get('hydrosphere') is False or self.params.get(
                'sea_percent') == 100:
            num_aquifers = 0

        print(
            "Making {} aquifers".format(num_aquifers)) if self.debug else False
        aquifers = []
        while len(aquifers) < num_aquifers:
            rx = random.randint(0, len(self.hex_grid.grid) - 1)
            ry = random.randint(0, len(self.hex_grid.grid) - 1)
            hex = self.hex_grid.grid[rx][ry]
            if hex.is_land and hex.moisture < 5:
                aquifers.append(hex)

        for hex in aquifers:
            # print("Aquifer at ", hex)
            r1 = hex.bubble(distance=3)
            for hex in r1:
                if hex.is_land:
                    hex.moisture += random.randint(0, 2)
            r2 = hex.bubble(distance=2)
            for hex in r2:
                if hex.is_land:
                    hex.moisture += 1
            r3 = hex.surrounding
            for hex in r3:
                if hex.is_land:
                    hex.moisture += 1

        # decide terrain features
        print("Making terrain features") if self.debug else False
        # craters only form in barren planets with a normal or lower atmosphere
        if self.params.get('craters') is True:

            # decide number of craters
            num_craters = random.randint(0, 15)
            print("Making {} craters".format(num_craters))
            craters = []

            while len(craters) < num_craters:
                size = random.randint(1, 3)
                craters.append(
                    dict(hex=random.choice(self.hex_grid.hexes),
                         size=size,
                         depth=10 * size))

            for crater in craters:

                center_hex = crater.get('hex')
                size = crater.get('size')
                depth = crater.get('depth')
                hexes = []

                if size >= 1:
                    hexes = center_hex.surrounding
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 5
                        h.altitude = max(h.altitude, 0)
                if size >= 2:
                    hexes = center_hex.bubble(distance=2)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 10
                        h.altitude = max(h.altitude, 0)

                if size >= 3:
                    hexes = center_hex.bubble(distance=3)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 15
                        h.altitude = max(h.altitude, 0)
                for h in hexes[:round(len(hexes) / 3)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.crater) is False:
                            i.add_feature(HexFeature.crater)
                            i.altitude = center_hex.altitude - 20
                            i.altitude = max(i.altitude, 0)

        # volcanoes
        if self.params.get('volcanoes'):

            num_volcanoes = random.randint(0, 10)
            print("Making {} volcanoes".format(num_volcanoes))
            volcanoes = []
            while len(volcanoes) < num_volcanoes:
                center_hex = random.choice(self.hex_grid.hexes)
                if center_hex.altitude > 50:
                    size = random.randint(1, 5)
                    height = random.randint(30, 70)
                    volcanoes.append(
                        dict(hex=center_hex, size=size, height=height))

            for volcano in volcanoes:
                height = volcano.get('height')
                size = volcano.get('size')
                center_hex = volcano.get('hex')
                print("\tVolcano: Size: {}, Height: {}".format(size, height))
                size_list = list(range(size))
                size_list.reverse()
                hexes = []
                for i in size_list:
                    i += 1
                    this_height = round(height / i)
                    if i == 1:
                        l = center_hex.surrounding + [center_hex]
                    else:
                        l = center_hex.bubble(distance=i)
                    for h in l:
                        hexes.append(h)
                        h.altitude = center_hex.altitude + this_height
                        h.add_feature(HexFeature.volcano)

                last_altitude = 0
                for h in hexes[:round(len(hexes) / 2)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.volcano) is False:
                            i.add_feature(HexFeature.volcano)
                            i.altitude += 5
                            i.altitude = min(i.altitude, 255)
                            last_altitude = i.altitude
                center_hex.altitude += last_altitude + 5

                # lava flow
                def step(active_hex):
                    if active_hex.altitude < 50:
                        return
                    else:
                        active_hex.add_feature(HexFeature.lava_flow)
                        found = []
                        for i in active_hex.surrounding:
                            if i.altitude <= active_hex.altitude and i.has_feature(
                                    HexFeature.lava_flow) is False:
                                found.append(i)
                        found.sort(key=lambda x: x.altitude)
                        if len(found) > 1:
                            step(found[0])
                        if len(found) > 2:
                            step(found[1])

                step(center_hex)

        self.territories = []
        self.generate_territories()
        self.generate_resources()
        self.geoforms = []
        self._determine_landforms()

        print("Done") if self.debug else False
コード例 #8
0
class MapGen:
    """ generates a heightmap as an array of integers between 1 and 255
    using the diamond-square algorithm"""
    def __init__(self, params, debug=False):
        """ initialize """
        self.params = default_params
        self.params.update(params)

        if debug:
            print("Making world with params:")
            for key, value in params.items():
                print("\t{}:\t{}".format(key, value))

        self.debug = debug

        if type(params.get('random_seed')) is int:
            random.seed(params.get('random_seed'))

        with Timer("Building Heightmap", self.debug):
            self.heightmap = Heightmap(self.params, self.debug)

        self.hex_grid = Grid(self.heightmap, self.params)
        if self.debug is True:
            print("\tAverage Height: {}".format(self.hex_grid.average_height))
            print("\tHighest Height: {}".format(self.hex_grid.highest_height))
            print("\tLowest Height: {}".format(self.hex_grid.lowest_height))

        print("Making calendar")
        self.calendar = Calendar(self.params.get('year_length'),
                                 self.params.get('day_length'))

        self.rivers = []
        self.rivers_sources = []

        with Timer("Computing hex distances", self.debug):
            self._get_distances()

        self._generate_pressure()

        if self.params.get('hydrosphere'):
            self._generate_rivers()

            # give coastal land hexes moisture based on how close to the coast they are
            # TODO: replace with more realistic model
            print("Making coastal moisture") if self.debug else False
            for y, row in enumerate(self.hex_grid.grid):
                for x, col in enumerate(row):
                    hex = self.hex_grid.grid[x][y]
                    if hex.is_land:
                        if hex.distance <= 5:
                            hex.moisture += 1
                        if hex.distance <= 3:
                            hex.moisture += random.randint(1, 3)
                        if hex.distance <= 1:
                            hex.moisture += random.randint(1, 6)

        # generate aquifers
        num_aquifers = random.randint(5, 25)

        if self.params.get('hydrosphere') is False or self.params.get(
                'sea_percent') == 100:
            num_aquifers = 0

        print(
            "Making {} aquifers".format(num_aquifers)) if self.debug else False
        aquifers = []
        while len(aquifers) < num_aquifers:
            rx = random.randint(0, len(self.hex_grid.grid) - 1)
            ry = random.randint(0, len(self.hex_grid.grid) - 1)
            hex = self.hex_grid.grid[rx][ry]
            if hex.is_land and hex.moisture < 5:
                aquifers.append(hex)

        for hex in aquifers:
            # print("Aquifer at ", hex)
            r1 = hex.bubble(distance=3)
            for hex in r1:
                if hex.is_land:
                    hex.moisture += random.randint(0, 2)
            r2 = hex.bubble(distance=2)
            for hex in r2:
                if hex.is_land:
                    hex.moisture += 1
            r3 = hex.surrounding
            for hex in r3:
                if hex.is_land:
                    hex.moisture += 1

        # decide terrain features
        print("Making terrain features") if self.debug else False
        # craters only form in barren planets with a normal or lower atmosphere
        if self.params.get('craters') is True:

            # decide number of craters
            num_craters = random.randint(0, 15)
            print("Making {} craters".format(num_craters))
            craters = []

            while len(craters) < num_craters:
                size = random.randint(1, 3)
                craters.append(
                    dict(hex=random.choice(self.hex_grid.hexes),
                         size=size,
                         depth=10 * size))

            for crater in craters:

                center_hex = crater.get('hex')
                size = crater.get('size')
                depth = crater.get('depth')
                hexes = []

                if size >= 1:
                    hexes = center_hex.surrounding
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 5
                        h.altitude = max(h.altitude, 0)
                if size >= 2:
                    hexes = center_hex.bubble(distance=2)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 10
                        h.altitude = max(h.altitude, 0)

                if size >= 3:
                    hexes = center_hex.bubble(distance=3)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 15
                        h.altitude = max(h.altitude, 0)
                for h in hexes[:round(len(hexes) / 3)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.crater) is False:
                            i.add_feature(HexFeature.crater)
                            i.altitude = center_hex.altitude - 20
                            i.altitude = max(i.altitude, 0)

        # volcanoes
        if self.params.get('volcanoes'):

            num_volcanoes = random.randint(0, 10)
            print("Making {} volcanoes".format(num_volcanoes))
            volcanoes = []
            while len(volcanoes) < num_volcanoes:
                center_hex = random.choice(self.hex_grid.hexes)
                if center_hex.altitude > 50:
                    size = random.randint(1, 5)
                    height = random.randint(30, 70)
                    volcanoes.append(
                        dict(hex=center_hex, size=size, height=height))

            for volcano in volcanoes:
                height = volcano.get('height')
                size = volcano.get('size')
                center_hex = volcano.get('hex')
                print("\tVolcano: Size: {}, Height: {}".format(size, height))
                size_list = list(range(size))
                size_list.reverse()
                hexes = []
                for i in size_list:
                    i += 1
                    this_height = round(height / i)
                    if i == 1:
                        l = center_hex.surrounding + [center_hex]
                    else:
                        l = center_hex.bubble(distance=i)
                    for h in l:
                        hexes.append(h)
                        h.altitude = center_hex.altitude + this_height
                        h.add_feature(HexFeature.volcano)

                last_altitude = 0
                for h in hexes[:round(len(hexes) / 2)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.volcano) is False:
                            i.add_feature(HexFeature.volcano)
                            i.altitude += 5
                            i.altitude = min(i.altitude, 255)
                            last_altitude = i.altitude
                center_hex.altitude += last_altitude + 5

                # lava flow
                def step(active_hex):
                    if active_hex.altitude < 50:
                        return
                    else:
                        active_hex.add_feature(HexFeature.lava_flow)
                        found = []
                        for i in active_hex.surrounding:
                            if i.altitude <= active_hex.altitude and i.has_feature(
                                    HexFeature.lava_flow) is False:
                                found.append(i)
                        found.sort(key=lambda x: x.altitude)
                        if len(found) > 1:
                            step(found[0])
                        if len(found) > 2:
                            step(found[1])

                step(center_hex)

        self.territories = []
        self.generate_territories()
        self.generate_resources()
        self.geoforms = []
        self._determine_landforms()

        print("Done") if self.debug else False

    def generate_resources(self):
        print("Placing resources")
        ratings = HexResourceRating.list()
        types = HexResourceType.list()

        combined = []

        for r in ratings:
            for t in types:
                combined.append(dict(rating=r, type=t))
        for h in self.hex_grid.hexes:
            for resource in combined:
                chance = (resource.get('rating').rarity *
                          resource.get('type').rarity * self.hex_grid.size /
                          1000) / (math.pow(self.hex_grid.size, 2))
                given = random.uniform(0, 1)
                if given <= chance:
                    h.resource = resource

    def generate_territories(self):
        """
         Makes territories
        """
        # select number of territories to place
        land_percent = 100 - self.params.get('sea_percent')
        num_territories = self.params.get('num_territories')

        # give each a land pixel to start
        print("Making {} territories".format(
            num_territories)) if self.debug else False

        c = 0
        if num_territories == 0:
            return
        while len(self.territories) < num_territories:
            rx = random.randint(0, len(self.hex_grid.grid) - 1)
            ry = random.randint(0, len(self.hex_grid.grid) - 1)
            hex_s = self.hex_grid.grid[rx][ry]
            if hex_s.is_land:
                color = random.randint(0, 255), random.randint(
                    0, 255), random.randint(0, 255)
                self.territories.append(
                    Territory(self.hex_grid, hex_s, c, color))
                c += 1

        # loop over each, adding hexes
        total_hexes = self.hex_grid.size * self.hex_grid.size
        count = 0
        while count < total_hexes:  #  i in range(0, 15):
            count = 0
            # print("Start: {} < {}".format(count, total_hexes))
            territories = self.territories
            random.shuffle(territories)
            for t in territories:
                frontier = t.frontier
                for f in frontier:
                    if f.is_owned is False:
                        f.territory = t
                        t.members.append(f)
                        t.last_added.append(f)
                count += t.size
            # print("End: {} < {}".format(count, total_hexes))

        # remove water hexes
        for t in self.territories:
            members = t.members
            t.members = [h for h in t.members if h.is_land]
            water_hexes = (h for h in members if h.is_water)
            for h in water_hexes:
                h.territory = None

        # merge territories
        print("Merging barren territories")

        if self.params.get('num_territories') > 0:
            top = []
            bottom = []
            for t in self.territories:
                avg_x = round(sum([i.x for i in t.members]) / len(t.members))
                if t.avg_temp < 0 and (avg_x / self.hex_grid.size) < 0.5:
                    top.append(t)
                elif t.avg_temp < 0 and (avg_x / self.hex_grid.size) >= 0.5:
                    bottom.append(t)

            pick_top = None
            pick_bottom = None
            if len(top) > 0:
                print("Merging {} territories from the top of the map".format(
                    len(top)))
                pick_top = random.choice(top)
                top.remove(pick_top)
                for t in self.territories:
                    if t in top:
                        pick_top.members += t.members
                        t.members = []

            if len(bottom) > 0:
                print(
                    "Merging {} territories from the bottom of the map".format(
                        len(bottom)))
                pick_bottom = random.choice(bottom)
                bottom.remove(pick_bottom)
                for t in self.territories:
                    if t in bottom:
                        pick_bottom.members += t.members
                        t.members = []

            if len(top) > 0:
                for h in pick_top.members:
                    h.territory = pick_top

            if len(bottom) > 0:
                for h in pick_bottom.members:
                    h.territory = pick_bottom

            self.territories = [t for t in self.territories if t is not None]

            print("{} empty territories being deleted".format(
                len([t for t in self.territories if len(t.members) == 0])))
            self.territories = [
                t for t in self.territories if len(t.members) > 0
            ]

            print("There are now {} territories".format(len(self.territories)))

        print("Splitting territories into contiguous blocks"
              ) if self.debug else False
        for t in self.territories:
            t.find_groups()

    def _get_distances(self):
        """
        Gets the distances each land pixel is to the coastline.
        TODO: Make this more efficient
        """

        if not self.params.get('hydrosphere'):
            # we don't care about distances otherwise
            return

        for y, row in enumerate(self.hex_grid.grid):
            for x, col in enumerate(row):
                h = self.hex_grid.grid[x][y]
                if h.is_land:
                    count = 1
                    numbers = []

                    east = h.hex_east
                    while east.is_land is True and count < self.hex_grid.size * 2:
                        east = east.hex_east
                        count += 1
                    numbers.append(count)
                    count = 1

                    west = h.hex_west
                    while west.is_land is True and count < self.hex_grid.size * 2:
                        west = west.hex_west
                        count += 1
                    numbers.append(count)
                    count = 1

                    north_east = h.hex_north_east
                    while north_east.is_land is True and count < self.hex_grid.size * 2:
                        north_east = north_east.hex_north_east
                        count += 1
                    numbers.append(count)
                    count = 1

                    north_west = h.hex_north_west
                    while north_west.is_land is True and count < self.hex_grid.size * 2:
                        north_west = north_west.hex_north_west
                        count += 1

                    numbers.append(count)
                    count = 1

                    south_west = h.hex_south_west
                    while south_west.is_land is True and count < self.hex_grid.size * 2:
                        south_west = south_west.hex_south_west
                        count += 1
                    numbers.append(count)
                    count = 1

                    south_east = h.hex_south_east
                    while south_east.is_land is True and count < self.hex_grid.size * 2:
                        south_east = south_east.hex_south_east
                        count += 1
                    numbers.append(count)

                    h.distance = min(numbers)

    def _generate_pressure(self):

        with Timer("Generating pressure", self.debug):
            base_pressure = self.hex_grid.params.get('surface_pressure')

            with Timer("    calculating pressure zones", self.debug):
                # calcualte pressure caused by pressure zones
                pressure_diff = random.randint(3, 5)
                for y, row in enumerate(self.hex_grid.grid):
                    for x, col in enumerate(row):
                        h = self.hex_grid.grid[x][y]

                        # end_year is winter, mid_year is summer
                        if h.is_land:
                            max_shift = round(h.distance / 2)
                            end_year = pressure_at_seasons(
                                h.latitude, base_pressure, pressure_diff,
                                -max_shift)
                            mid_year = pressure_at_seasons(
                                h.latitude, base_pressure, pressure_diff,
                                max_shift)
                        else:
                            max_shift = min(
                                6, 0.005 *
                                round(self.hex_grid.sealevel - h.latitude))
                            end_year = pressure_at_seasons(
                                h.latitude, base_pressure, pressure_diff,
                                -max_shift)
                            mid_year = pressure_at_seasons(
                                h.latitude, base_pressure, pressure_diff,
                                max_shift)
                        h.pressure = (end_year, mid_year)

            # sort all hexes by land and water, lowest to highest
            with Timer("    sorting hexes into groups", self.debug):
                land_hexes = [h for h in self.hex_grid.hexes if h.is_land]
                water_hexes = [h for h in self.hex_grid.hexes if not h.is_land]
                land_hexes.sort(key=lambda x: x.altitude, reverse=True)
                water_hexes.sort(key=lambda x: x.altitude)

            def decide_change(h, incr):
                if h.is_land:
                    if h.hemisphere is Hemisphere.northern:
                        # winter / increase
                        # summer / decrease
                        return (h.pressure[0] + incr, h.pressure[1] - incr)
                    elif h.hemisphere is Hemisphere.southern:
                        # winter / decrease
                        # summer / increase
                        return (h.pressure[0] - incr, h.pressure[1] + incr)
                else:
                    if h.hemisphere is Hemisphere.northern:
                        # winter / decrease
                        # summer / increase
                        return (h.pressure[0] - incr, h.pressure[1] + incr)
                    elif h.hemisphere is Hemisphere.southern:
                        # winter / increase
                        # summer / decrease
                        return (h.pressure[0] + incr, h.pressure[1] - incr)
                    # return (h.pressure[0], h.pressure[1])

            def brush(percent, incr):
                matching_land_hexes = land_hexes[
                    0:round(len(land_hexes) * percent)]
                matching_water_hexes = water_hexes[
                    0:round(len(water_hexes) * percent)]

                for h in matching_land_hexes:
                    for h in h.bubble(3):
                        h.pressure = decide_change(h, incr * h.zone.incr)
                for h in matching_water_hexes:
                    for h in h.bubble(3):
                        h.pressure = decide_change(h, incr * h.zone.incr)

            brush(0.80, 0.05)
            brush(0.30, 0.10)
            brush(0.10, 0.10)

        # decide wind directions
        # Wind consists of a HexEdge direction and a magnitude that is equal to the difference in pressure
        # Wind direction is always to the neighbor with the lowest pressure,
        # deflected by the following rules:
        # Northern Hemisphere:
        #     high pressure areas: clockwise
        #     low pressure areas: counter-clockwise
        # Southern Hemisphere:
        #     high pressure areas: counter-clockwise
        #     low pressure areas: clockwise
        with Timer("Generating wind", self.debug):
            for y, row in enumerate(self.hex_grid.grid):
                for x, col in enumerate(row):
                    h = self.hex_grid.grid[x][y]
                    h.wind = (decide_wind(0, base_pressure,
                                          h), decide_wind(1, base_pressure, h))

        # IDEA 1
        # If hex is warmer than downstream: increase temperature downstream 20 hexes
        # If hex is colder than downstream: decrease temperature downstream 20 hexes
        # downstream hexes are neighboring hexes that have lower pressure
        # magnitude depends on pressure difference
        # Visit each hex. Steps: N*N*20 where N is map size

        # IDEA 2
        # going downstream, bring each hex's temperature close to the starting hex's temperature
        # less and less each loop, with loop 1 being very close and loop 20 being barely changed

        # IDEA 3
        # Visiting every hex, start a loop downstream until you reach a hex you have already visited
        # in this loop, averaging every hex's temperature with the last visited hex's temperature
        # weighted average favoring hex's base temperature when wind is less strong
        def windgust(season_index, starting_hex, loops=20):
            downstream_hex = starting_hex.wind[season_index].get(
                'windward_hex')
            temp_change = ((20 / (loops + 1)) / 20) * 10
            if starting_hex.base_temperature[
                    season_index] > downstream_hex.base_temperature[
                        season_index]:
                # increase temperature at downstream hex
                downstream_hex.wind_temp_effect[season_index] = temp_change / 2
                # decrease temperature at this hex
                starting_hex.wind_temp_effect[season_index] = -(temp_change /
                                                                2)
            else:
                # decrease temperature at downstream hex
                downstream_hex.wind_temp_effect[season_index] = -(temp_change /
                                                                  2)
                # increase temperature at this hex
                starting_hex.wind_temp_effect[season_index] = temp_change / 2

            # go on to the next hex in line
            if loops != 0:
                next_hex = downstream_hex.wind[season_index].get(
                    'windward_hex')
                windgust(season_index, next_hex, loops - 1)

        with Timer("Generating Temperature Changes", self.debug):
            for y, row in enumerate(self.hex_grid.grid):
                for x, col in enumerate(row):
                    h = self.hex_grid.grid[x][y]

                    # end year
                    windgust(0, h)

                    # mid year
                    windgust(1, h)

    def _generate_rivers(self):
        """
        For each river source edge:
            If the "down" hex of the left edge is the "one" or "two" hexes of this edge,
                the left edge is invalid
            If the "down" hex of the right edge is the "one" or "two" hexes of this edge,
                the right edge is invalid
            If two are valid:
                E = lowest slope edge
                If E.down is below sea level, end here
                otherwise add this edge as a river segment
            else if one is valid:
                E = valid edge
                If E.down is below sea level, end here
                otherwise add this edge as a river segment
            else if both are invalid:
                Make a lake at the lowest of the "one" or "two" hexes of this edge
                Make a new river source edge at an random edge pointing out from this lake
                    that has a direction pointing out from the lake
        """
        land_percent = 100 - self.params.get('sea_percent')
        num_rivers = self.params.get('num_rivers')
        print("Making {} rivers".format(num_rivers)) if self.debug else False

        while len(self.rivers_sources) < num_rivers:
            rx = random.randint(0, self.hex_grid.size - 1)
            ry = random.randint(0, self.hex_grid.size - 1)
            hex_s = self.hex_grid.find_hex(rx, ry)
            if hex_s.is_inland and hex_s.altitude > self.hex_grid.sealevel + 35:
                # if hex_s.temperature < 0:
                # TODO: Determine when to not place rivers at hight latitudes
                #     # don't place rivers above +35 altitude when the temperature is below zero
                #     continue
                random_side = random.choice(list(HexSide))
                #print("Placing river source at {}, {}".format(rx, ry))
                self.rivers_sources.append(
                    RiverSegment(self.hex_grid, rx, ry, random_side, True))

        print("Placed river sources") if self.debug else False

        for r in self.rivers_sources:  # loop over each source segment
            segment = r  # river segment we are looking at
            finished = False
            last_unselected = None
            # we stop only when one of two things happen:
            #   - a lake is formed
            #   - we reached sea level
            while finished is False:
                # print("Segment: {}, {}".format(segment.x, segment.y))
                side_one, side_two = segment.side.branching(
                    segment.edge.direction)
                down = segment.edge.down  # down-slope hex of this segment

                # add the moisture to the one and two hexes in a 3 radius
                one = segment.edge.one.bubble(distance=3)
                two = segment.edge.two.bubble(distance=3)
                both = list(set(one + two))
                for hex in both:
                    if hex.is_land:
                        hex.moisture += 1
                three = segment.edge.one.surrounding
                four = segment.edge.two.surrounding
                both = list(set(three + four))
                for hex in both:
                    if hex.is_land:
                        hex.moisture += 1

                # find the two Edges from the sides found branching
                edge_one = down.get_edge(side_one)
                edge_two = down.get_edge(side_two)

                # check if either of the edges are valid river segment locations
                one_valid = True
                two_valid = True
                if edge_one.down == segment.edge.one or edge_one.down == segment.edge.two:
                    one_valid = False
                if edge_two.down == segment.edge.one or edge_two.down == segment.edge.two:
                    two_valid = False

                if self.is_river(edge_one):
                    one_valid = False
                elif self.is_river(edge_two):
                    two_valid = False

                if one_valid and two_valid:
                    # print("\tBoth are valid edges")
                    if edge_one.down.altitude < edge_two.down.altitude:
                        selected = edge_one
                        selected_side = side_one
                        last_unselected = edge_two, side_two
                    else:
                        selected = edge_two
                        selected_side = side_two
                        last_unselected = edge_one, side_one
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x,
                                                selected.one.y, selected_side,
                                                False)
                    segment = segment.next
                elif one_valid is True and two_valid is False:
                    # print("\tOne is Valid")
                    selected = edge_one
                    last_unselected = edge_two, side_two
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x,
                                                selected.one.y, side_one,
                                                False)
                    segment = segment.next
                elif one_valid is False and two_valid is True:
                    # print("\tTwo is valid")
                    selected = edge_two
                    last_unselected = edge_one, side_one
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x,
                                                selected.one.y, side_two,
                                                False)
                    segment = segment.next
                else:
                    # import ipdb; ipdb.set_trace()
                    # segment.x = last_unselected[0].one.x
                    # segment.y = last_unselected[0].one.y
                    # segment.side = last_unselected[1]
                    # segment.is_source = True
                    # finished = True
                    # print("huh?")

                    # both edges are invalid, make lake at one or two
                    # if segment.edge.one.altitude < segment.edge.two.altitude:
                    #     lake = segment.edge.one
                    # else:
                    #     lake = segment.edge.two
                    # lake.add_feature(HexFeature.lake)

                    # moisture around lake increases
                    # surrounding = lake.surrounding
                    # for hex in surrounding:
                    #     if hex.is_land:
                    #         hex.moisture += 3

                    # print("\tMade a lake at {}, {}".format(segment.x, segment.y))

                    # make a new source river at an outer edge of the lake
                    # chosen_edge = random.choice(lake.outer_edges)
                    # self.rivers_sources.append(RiverSegment(self.hex_grid, chosen_edge.one.x, chosen_edge.one.y, chosen_edge.side, True))

                    finished = True

        final = []

        for r in self.rivers_sources:
            # remove rivers that are too small
            if r.size > 2:
                final.append(r)
                while r.next is not None:
                    # print("Segment: ", r.next)
                    final.append(r.next)
                    r = r.next
        for r in final:
            r.edge.is_river = True
        self.rivers = final

    def _determine_landforms(self):
        # single hex geoforms
        with Timer("Finding geographic features", self.debug):
            with Timer("\tPlacing initial geoforms", self.debug):
                for y, row in enumerate(self.hex_grid.grid):
                    for x, col in enumerate(row):
                        h = self.hex_grid.grid[x][y]

                        # Isthmus
                        if is_isthmus(h):
                            h.geoform_type = GeoformType.isthmus

                        # Bays
                        if is_bay(h):
                            h.geoform_type = GeoformType.bay

                        # Straits
                        if is_strait(h):
                            h.geoform_type = GeoformType.strait

                        # Peninsula
                        if is_peninsula(h):
                            h.geoform_type = GeoformType.peninsula

                        if h.geoform_type is not None:
                            self.geoforms.append(
                                Geoform(set([h]), h.geoform_type))

            def flood(found, current, hex_type):
                """ Do a flood fill at this hex over all hexes of this type without geoforms """
                if current.geoform_type is not None:
                    return set()
                if current in found:
                    return set()
                neighbors = [h[1] for h in current.neighbors]
                found.add(current)
                for neighbor in neighbors:
                    if neighbor.type is hex_type:
                        found.update(flood(found, neighbor, hex_type))
                return found

            def give_geoform(hexes, geoform_type):
                for h in hexes:
                    h.geoform_type = geoform_type

            # loop until every f*****g hex has a geoform
            # import ipdb; ipdb.set_trace()
            with Timer("\tFinding contiguous geoforms", self.debug):
                sys.setrecursionlimit(10000)
                current = first_hex_without_geoform(self.hex_grid.grid)
                while current is not None:
                    if current.is_land:
                        # try to find continents
                        hexes = flood(set(), current, current.type)
                        if len(hexes) < 25:
                            geotype = GeoformType.small_island
                        elif len(hexes) < 100:
                            geotype = GeoformType.large_island
                        else:
                            geotype = GeoformType.continent
                    else:
                        # try to find oceans
                        hexes = flood(set(), current, current.type)
                        if len(hexes) < 3:
                            geotype = GeoformType.lake
                        elif len(hexes) < 100:
                            geotype = GeoformType.sea
                        else:
                            geotype = GeoformType.ocean

                    give_geoform(hexes, geotype)
                    # hexes is a set of hexes
                    self.geoforms.append(Geoform(hexes, geotype))
                    # find a new hex
                    current = first_hex_without_geoform(self.hex_grid.grid)

            # now we have geoforms

            # FIND NEIGHBORING GEOFORMS
            def calculate_neighbors():
                """ recalculate neighboring geoforms """
                for geoform in self.geoforms:
                    geoform.neighbors.clear()
                    for h in geoform.hexes:
                        ng = [
                            n[1].geoform for n in h.neighbors
                            if n[1].geoform is not geoform
                        ]
                        geoform.neighbors.update(ng)
                    assert geoform not in geoform.neighbors, 'A Geoform should not be in its own neighbors set'

            calculate_neighbors()

            with Timer("\tMerging geoforms", self.debug):
                # MERGE GEOFORMS
                # merge all neighboring geoforms of like type
                for geoform in self.geoforms:
                    for neighbor in geoform.neighbors:
                        if geoform.type is neighbor.type:
                            # remove neighbor
                            print('Merging {} '.format(geoform.type))
                            geoform.merge(neighbor)

                calculate_neighbors()

                # if an island is next to a continent or island separated by an isthmus,
                # and that island doesn't have any other isthmuses
                # the island becomes a peninsula
                for geoform in self.geoforms:
                    if geoform.type is GeoformType.isthmus:
                        islands = geoform.neighbor_of_type(
                            GeoformType.small_island)
                        land_form = geoform.neighbor_of_types([
                            GeoformType.continent, GeoformType.small_island,
                            GeoformType.large_island
                        ])

                        if len(islands) == 1 and len(land_form) == 1 and \
                            len(land_form[0].neighbors) >= 2:
                            other_isthmuses = len(islands[0].neighbor_of_type(
                                GeoformType.isthmus)) > 1
                            # check to see if this island has other isthmuses
                            # if it does, exclude it
                            if other_isthmuses is False:
                                print(
                                    'Merging island + isthmus into peninsula')
                                islands[0].merge(
                                    geoform
                                )  # merge the island and the isthmus
                                islands[
                                    0].type = GeoformType.peninsula  # change island to peninsula

                calculate_neighbors()

                # small islands separated by an isthmus to a large island should
                # be merged into the large island
                for geoform in self.geoforms:
                    if geoform.type is GeoformType.small_island:
                        large_islands = geoform.neighbor_of_type(
                            GeoformType.large_island)
                        if len(large_islands) > 0:
                            print('Merging small island into large island')
                            large_islands[0].merge(geoform)

                calculate_neighbors()

                # islands separated by an isthmus with a continent should be merged
                # TODO: maybe large islands should be a new continent
                for geoform in self.geoforms:
                    if geoform.type is GeoformType.large_island or \
                       geoform.type is GeoformType.small_island:
                        isthmuses = geoform.neighbor_of_type(
                            GeoformType.isthmus)
                        continents = set()
                        for i in isthmuses:
                            continents.update(
                                i.neighbor_of_type(GeoformType.continent))
                        continents = list(continents)
                        if len(continents) == 1:
                            # one continent neighbor
                            print('Merging island into continent')
                            continents[0].merge(geoform)
                        elif len(continents) > 1:
                            # multiple continents are neighbors
                            print(
                                'Merging island and other continents into one continent'
                            )
                            continents[0].merge(geoform)
                            for c in continents[1:]:
                                continents[0].merge(c)

                calculate_neighbors()

                # if a peninsula is next to a isthmus, merge them into one peninsula
                for geoform in self.geoforms:
                    if geoform.type is GeoformType.peninsula:
                        isthmuses = geoform.neighbor_of_type(
                            GeoformType.isthmus)
                        if len(isthmuses) == 1:
                            print('Merging isthmus into peninsula')
                            geoform.merge(isthmuses[0])

                        # a peninsula of size 2 with no neighbors is an island
                        if geoform.size == 2 and len(geoform.neighbors) == 0:
                            geoform.type = GeoformType.small_island

                calculate_neighbors()

                # remove old geoforms
            print("Deleting {} geoforms".format(
                len([g for g in self.geoforms if g.to_delete is True])))
            self.geoforms = [g for g in self.geoforms if g.to_delete is False]
            print("There is now {} geoforms".format(len(self.geoforms)))

    def is_river(self, edge):
        """
        Determines if an edge has a river
        :param edge: Edge
        :return: Boolean
        """
        for r in self.rivers_sources:
            while r.next is not None:
                if r.edge == edge:
                    return True
                r = r.next
        return False

    def find_river(self, x, y):
        """ Finds river segments at an hex's x and y coordinates. Returns a list of EdgeSides
            representing where the river segments are """
        seg = []
        for s in self.rivers:
            if s.x == x and s.y == y:
                seg.append(s.side)
        return seg

    def export(self, filename):
        """ Export the map data as a JSON file """
        with Timer("Compiling data into dictionary", self.debug):
            params = copy.copy(self.params)
            params['map_type'] = params.get('map_type').to_dict()
            params['ocean_type'] = params.get('ocean_type').to_dict()
            data = {
                "parameters": params,
                "details": {
                    "size": self.hex_grid.size,
                    "sea_level": self.hex_grid.sealevel,
                    "avg_height": self.hex_grid.average_height,
                    "max_height": self.hex_grid.highest_height,
                    "min_height": self.hex_grid.lowest_height
                },
                "hexes": [],
                "geoforms": []
            }

            def edge_dict(edge):
                return dict(is_river=edge.is_river,
                            is_coast=edge.is_coast,
                            direction=edge.direction.name)

            for x, row in enumerate(self.hex_grid.grid):
                row_data = []
                for y, col in enumerate(row):
                    h = self.hex_grid.find_hex(x, y)
                    color_temperature = ((h.color_temperature[0][0] +
                                          h.color_temperature[1][0]) / 2,
                                         (h.color_temperature[0][1] +
                                          h.color_temperature[1][1]) / 2,
                                         (h.color_temperature[0][2] +
                                          h.color_temperature[1][2]) / 2)
                    temperature = round(
                        (h.temperature[0] + h.temperature[1]) / 2, 2)
                    row_data.append({
                        "id": h.id.hex,
                        "x": x,
                        "y": y,
                        "altitude": h.altitude,
                        "temperature": temperature,
                        "moisture": h.moisture,
                        "biome": h.biome.to_dict(),
                        "type": h.type.name,
                        "is_inland": h.is_inland,
                        "is_coast": h.is_coast,
                        "geoform": h.geoform.id.hex,
                        "colors": {
                            "satellite": h.color_satellite,
                            "terrain": h.color_terrain,
                            "temperature": color_temperature,
                            "biome": h.color_biome,
                            "rivers": h.color_rivers
                        },
                        "edges": {
                            "east": edge_dict(h.edge_east),
                            "north_east": edge_dict(h.edge_north_east),
                            "north_west": edge_dict(h.edge_north_west),
                            "west": edge_dict(h.edge_west),
                            "south_west": edge_dict(h.edge_south_west),
                            "south_east": edge_dict(h.edge_south_east)
                        }
                    })
                data['hexes'].append(row_data)
            for geoform in self.geoforms:
                data['geoforms'].append(geoform.to_dict())
        with open(filename, 'w') as outfile:
            with Timer("Writing data to JSON file", self.debug):
                json.dump(data, outfile)
        return data
コード例 #9
0
ファイル: mapgen.py プロジェクト: BinaryTiger/hexgen
class MapGen:
    """ generates a heightmap as an array of integers between 1 and 255
    using the diamond-square algorithm"""

    def __init__(self, params, debug=False):
        """ initialize """
        self.params = default_params
        self.params.update(params)

        if debug:
            print("Making world with params:")
            for key, value in params.items():
                print("\t{}:\t{}".format(key, value))


        self.debug = debug

        if type(params.get('random_seed')) is int:
            random.seed(params.get('random_seed'))

        self.heightmap = Heightmap(self.params)

        self.hex_grid = Grid(self.heightmap, self.params)

        self.rivers = []
        self.rivers_sources = []

        print("Computing hex distances") if self.debug else False
        self._get_distances()


        if self.params.get('hydrosphere'):
            self._generate_rivers()

            # give coastal land hexes moisture based on how close to the coast they are
            print("Making coastal moisture") if self.debug else False
            for y, row in enumerate(self.hex_grid.grid):
                for x, col in enumerate(row):
                    hex = self.hex_grid.grid[x][y]
                    if hex.is_land:
                        if hex.distance <= 5:
                            hex.moisture += 1
                        if hex.distance <= 3:
                            hex.moisture += random.randint(1, 3)
                        if hex.distance <= 1:
                            hex.moisture += random.randint(1, 6)

        # generate aquifers
        num_aquifers = random.randint(5, 25)

        if self.params.get('hydrosphere') is False or self.params.get('sea_percent') == 100:
            num_aquifers = 0

        print("Making {} aquifers".format(num_aquifers)) if self.debug else False
        aquifers = []
        while len(aquifers) < num_aquifers:
            rx = random.randint(0, len(self.hex_grid.grid) - 1)
            ry = random.randint(0, len(self.hex_grid.grid) - 1)
            hex = self.hex_grid.grid[rx][ry]
            if hex.is_land and hex.moisture < 5:
                aquifers.append(hex)

        for hex in aquifers:
            # print("Aquifer at ", hex)
            r1 = hex.bubble(distance=3)
            for hex in r1:
                if hex.is_land:
                    hex.moisture += random.randint(0, 2)
            r2 = hex.bubble(distance=2)
            for hex in r2:
                if hex.is_land:
                    hex.moisture += 1
            r3 = hex.surrounding
            for hex in r3:
                if hex.is_land:
                    hex.moisture += 1

        # decide terrain features
        print("Making terrain features") if self.debug else False
        # craters only form in barren planets with a normal or lower atmosphere
        if self.params.get('craters') is True:

            # decide number of craters
            num_craters = random.randint(0, 15)
            print("Making {} craters".format(num_craters))
            craters = []

            while len(craters) < num_craters:
                size = random.randint(1, 3)
                craters.append(dict(hex=random.choice(self.hex_grid.hexes),
                                    size=size,
                                    depth= 10 * size))

            for crater in craters:

                center_hex = crater.get('hex')
                size = crater.get('size')
                depth = crater.get('depth')
                hexes = []

                if size >= 1:
                    hexes = center_hex.surrounding
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 5
                        h.altitude = max(h.altitude, 0)
                if size >= 2:
                    hexes = center_hex.bubble(distance=2)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 10
                        h.altitude = max(h.altitude, 0)

                if size >= 3:
                    hexes = center_hex.bubble(distance=3)
                    for h in hexes:
                        h.add_feature(HexFeature.crater)
                        h.altitude = center_hex.altitude - 15
                        h.altitude = max(h.altitude, 0)
                for h in hexes[:round(len(hexes)/3)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.crater) is False:
                            i.add_feature(HexFeature.crater)
                            i.altitude = center_hex.altitude - 20
                            i.altitude = max(i.altitude, 0)


        # volcanoes
        if self.params.get('volcanoes'):

            num_volcanoes = random.randint(0, 10)
            print("Making {} volcanoes".format(num_volcanoes))
            volcanoes = []
            while len(volcanoes) < num_volcanoes:
                center_hex = random.choice(self.hex_grid.hexes)
                if center_hex.altitude > 50:
                    size = random.randint(1, 5)
                    height = random.randint(30, 70)
                    volcanoes.append(dict(hex=center_hex, size=size, height=height))

            for volcano in volcanoes:
                height = volcano.get('height')
                size = volcano.get('size')
                center_hex = volcano.get('hex')
                print("\tVolcano: Size: {}, Height: {}".format(size, height))
                size_list = list(range(size))
                size_list.reverse()
                hexes = []
                for i in size_list:
                    i += 1
                    this_height = round(height / i)
                    if i == 1:
                        l = center_hex.surrounding + [center_hex]
                    else:
                        l = center_hex.bubble(distance=i)
                    for h in l:
                        hexes.append(h)
                        h.altitude = center_hex.altitude + this_height
                        h.add_feature(HexFeature.volcano)

                last_altitude = 0
                for h in hexes[:round(len(hexes)/2)]:
                    for i in h.surrounding:
                        if i.has_feature(HexFeature.volcano) is False:
                            i.add_feature(HexFeature.volcano)
                            i.altitude += 5
                            i.altitude = min(i.altitude, 255)
                            last_altitude = i.altitude
                center_hex.altitude += last_altitude + 5

                # lava flow
                def step(active_hex):
                    if active_hex.altitude < 50:
                        return
                    else:
                        active_hex.add_feature(HexFeature.lava_flow)
                        found = []
                        for i in active_hex.surrounding:
                            if i.altitude <= active_hex.altitude and i.has_feature(HexFeature.lava_flow) is False:
                                found.append(i)
                        found.sort(key=lambda x: x.altitude)
                        if len(found) > 1:
                            step(found[0])
                        if len(found) > 2:
                            step(found[1])

                step(center_hex)

        self.territories = []
        self.generate_territories()
        self.generate_resources()

        print("Done") if self.debug else False

    def generate_resources(self):
        print("Placing resources")
        ratings = HexResourceRating.list()
        types = HexResourceType.list()

        combined = []

        for r in ratings:
            for t in types:
                combined.append(dict(rating=r,
                                     type=t))
        for h in self.hex_grid.hexes:
            for resource in combined:
                chance = (resource.get('rating').rarity *
                          resource.get('type').rarity * self.hex_grid.size / 1000 ) / (math.pow(self.hex_grid.size, 2))
                given = random.uniform(0, 1)
                if given <= chance:
                    h.resource = resource

    def generate_territories(self):
        """
         Makes territories
        """
        # select number of territories to place
        land_percent = 100 - self.params.get('sea_percent')
        num_territories = self.params.get('num_territories')

        # give each a land pixel to start
        print("Making {} territories".format(num_territories)) if self.debug else False

        c = 0
        if num_territories == 0:
            return
        while len(self.territories) < num_territories:
            rx = random.randint(0, len(self.hex_grid.grid) - 1)
            ry = random.randint(0, len(self.hex_grid.grid) - 1)
            hex_s = self.hex_grid.grid[rx][ry]
            if hex_s.is_land:
                color = random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)
                self.territories.append(Territory(self.hex_grid, hex_s, c, color))
                c += 1

        # loop over each, adding hexes
        total_hexes = self.hex_grid.size * self.hex_grid.size
        count = 0
        while count < total_hexes:  #  i in range(0, 15):
            count = 0
            # print("Start: {} < {}".format(count, total_hexes))
            territories = self.territories
            random.shuffle(territories)
            for t in territories:
                frontier = t.frontier
                for f in frontier:
                    if f.is_owned is False:
                        f.territory = t
                        t.members.append(f)
                        t.last_added.append(f)
                count += t.size
            # print("End: {} < {}".format(count, total_hexes))

        # remove water hexes
        for t in self.territories:
            members = t.members
            t.members = [h for h in t.members if h.is_land]
            water_hexes = (h for h in members if h.is_water)
            for h in water_hexes:
                h.territory = None

        # merge territories
        print("Merging barren territories")

        if self.params.get('num_territories') > 0:
            top = []
            bottom = []
            for t in self.territories:
                avg_x = round(sum([i.x for i in t.members]) / len(t.members))
                if t.avg_temp < 0 and (avg_x / self.hex_grid.size) < 0.5:
                    top.append(t)
                elif t.avg_temp < 0 and (avg_x / self.hex_grid.size) >= 0.5:
                    bottom.append(t)

            pick_top = None
            pick_bottom = None
            if len(top) > 0:
                print("Merging {} territories from the top of the map".format( len(top) ))
                pick_top = random.choice(top)
                top.remove(pick_top)
                for t in self.territories:
                    if t in top:
                        pick_top.members += t.members
                        t.members = []

            if len(bottom) > 0:
                print("Merging {} territories from the bottom of the map".format( len(bottom) ))
                pick_bottom = random.choice(bottom)
                bottom.remove(pick_bottom)
                for t in self.territories:
                    if t in bottom:
                        pick_bottom.members += t.members
                        t.members = []

            if len(top) > 0:
                for h in pick_top.members:
                    h.territory = pick_top

            if len(bottom) > 0:
                for h in pick_bottom.members:
                    h.territory = pick_bottom

            self.territories = [t for t in self.territories if t is not None]

            print("{} empty territories being deleted".format(len([t for t in self.territories if len(t.members) == 0])))
            self.territories = [t for t in self.territories if len(t.members) > 0]

            print("There are now {} territories".format(len(self.territories)))

        print("Splitting territories into contiguous blocks") if self.debug else False
        for t in self.territories:
            t.find_groups()

    def _get_distances(self):
        """
        Gets the distances each land pixel is to the coastline.
        TODO: Make this more efficient
        """

        if not self.params.get('hydrosphere'):
            # we don't care about distances otherwise
            return

        for y, row in enumerate(self.hex_grid.grid):
            for x, col in enumerate(row):
                h = self.hex_grid.grid[x][y]
                if h.is_land:
                    count = 1
                    numbers = []

                    east = h.hex_east
                    while east.is_land is True and count < self.hex_grid.size * 2:
                        east = east.hex_east
                        count += 1
                    numbers.append(count)
                    count = 1

                    west = h.hex_west
                    while west.is_land is True and count < self.hex_grid.size * 2:
                        west = west.hex_west
                        count += 1
                    numbers.append(count)
                    count = 1


                    north_east = h.hex_north_east
                    while north_east.is_land is True and count < self.hex_grid.size * 2:
                        north_east = north_east.hex_north_east
                        count += 1
                    numbers.append(count)
                    count = 1


                    north_west = h.hex_north_west
                    while north_west.is_land is True and count < self.hex_grid.size * 2:
                        north_west = north_west.hex_north_west
                        count += 1

                    numbers.append(count)
                    count = 1


                    south_west = h.hex_south_west
                    while south_west.is_land is True and count < self.hex_grid.size * 2:
                        south_west = south_west.hex_south_west
                        count += 1
                    numbers.append(count)
                    count = 1

                    south_east = h.hex_south_east
                    while south_east.is_land is True and count < self.hex_grid.size * 2:
                        south_east = south_east.hex_south_east
                        count += 1
                    numbers.append(count)

                    h.distance = min(numbers)

    def _generate_rivers(self):
        """
        For each river source edge:
            If the "down" hex of the left edge is the "one" or "two" hexes of this edge,
                the left edge is invalid
            If the "down" hex of the right edge is the "one" or "two" hexes of this edge,
                the right edge is invalid
            If two are valid:
                E = lowest slope edge
                If E.down is below sea level, end here
                otherwise add this edge as a river segment
            else if one is valid:
                E = valid edge
                If E.down is below sea level, end here
                otherwise add this edge as a river segment
            else if both are invalid:
                Make a lake at the lowest of the "one" or "two" hexes of this edge
                Make a new river source edge at an random edge pointing out from this lake
                    that has a direction pointing out from the lake
        """
        land_percent = 100 - self.params.get('sea_percent')
        num_rivers = self.params.get('num_rivers')
        print("Making {} rivers".format(num_rivers)) if self.debug else False

        while len(self.rivers_sources) < num_rivers:
            rx = random.randint(0, self.hex_grid.size - 1)
            ry = random.randint(0, self.hex_grid.size - 1)
            hex_s = self.hex_grid.find_hex(rx, ry)
            if hex_s.is_inland and hex_s.altitude > self.hex_grid.sealevel + 35:
                if hex_s.temperature < 0:
                    # don't place rivers above +35 altitude when the temperature is below zero
                    continue
                random_side = random.choice(list(HexSide))
                #print("Placing river source at {}, {}".format(rx, ry))
                self.rivers_sources.append(RiverSegment(self.hex_grid, rx, ry, random_side, True))

        print("Placed river sources") if self.debug else False

        for r in self.rivers_sources: # loop over each source segment
            segment = r # river segment we are looking at
            finished = False
            last_unselected = None
            # we stop only when one of two things happen:
            #   - a lake is formed
            #   - we reached sea level
            while finished is False:
                # print("Segment: {}, {}".format(segment.x, segment.y))
                side_one, side_two = segment.side.branching(segment.edge.direction)
                down = segment.edge.down  # down-slope hex of this segment

                # add the moisture to the one and two hexes in a 3 radius
                one = segment.edge.one.bubble(distance=3)
                two = segment.edge.two.bubble(distance=3)
                both = list(set(one + two))
                for hex in both:
                    if hex.is_land:
                        hex.moisture += 1
                three = segment.edge.one.surrounding
                four = segment.edge.two.surrounding
                both = list(set(three + four))
                for hex in both:
                    if hex.is_land:
                        hex.moisture += 1

                # find the two Edges from the sides found branching
                edge_one = down.get_edge(side_one)
                edge_two = down.get_edge(side_two)

                # check if either of the edges are valid river segment locations
                one_valid = True
                two_valid = True
                if edge_one.down == segment.edge.one or edge_one.down == segment.edge.two:
                    one_valid = False
                if edge_two.down == segment.edge.one or edge_two.down == segment.edge.two:
                    two_valid = False

                if self.is_river(edge_one):
                    one_valid = False
                elif self.is_river(edge_two):
                    two_valid = False

                if one_valid and two_valid:
                    # print("\tBoth are valid edges")
                    if edge_one.down.altitude < edge_two.down.altitude:
                        selected = edge_one
                        selected_side = side_one
                        last_unselected = edge_two, side_two
                    else:
                        selected = edge_two
                        selected_side = side_two
                        last_unselected = edge_one, side_one
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x, selected.one.y, selected_side, False)
                    segment = segment.next
                elif one_valid is True and two_valid is False:
                    # print("\tOne is Valid")
                    selected = edge_one
                    last_unselected = edge_two, side_two
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x, selected.one.y, side_one, False)
                    segment = segment.next
                elif one_valid is False and two_valid is True:
                    # print("\tTwo is valid")
                    selected = edge_two
                    last_unselected = edge_one, side_one
                    if selected.down.altitude < self.hex_grid.sealevel:
                        finished = True
                    segment.next = RiverSegment(self.hex_grid, selected.one.x, selected.one.y, side_two, False)
                    segment = segment.next
                else:
                    # import ipdb; ipdb.set_trace()
                    # segment.x = last_unselected[0].one.x
                    # segment.y = last_unselected[0].one.y
                    # segment.side = last_unselected[1]
                    # segment.is_source = True
                    # finished = True
                    # print("huh?")

                    # both edges are invalid, make lake at one or two
                    if segment.edge.one.altitude < segment.edge.two.altitude:
                        lake = segment.edge.one
                    else:
                        lake = segment.edge.two
                    lake.add_feature(HexFeature.lake)

                    # moisture around lake increases
                    surrounding = lake.surrounding
                    for hex in surrounding:
                        if hex.is_land:
                            hex.moisture += 3

                    # print("\tMade a lake at {}, {}".format(segment.x, segment.y))
                    #
                    # # make a new source river at an outer edge of the lake
                    # chosen_edge = random.choice(lake.outer_edges)
                    # self.rivers_sources.append(RiverSegment(self.hex_grid, chosen_edge.one.x, chosen_edge.one.y, chosen_edge.side, True))
                    finished = True

        final = []

        for r in self.rivers_sources:
            # remove rivers that are too small
            if r.size > 2:
                final.append(r)
                while r.next is not None:
                    # print("Segment: ", r.next)
                    final.append(r.next)
                    r = r.next
        self.rivers = final

    def is_river(self, edge):
        """
        Determines if an edge has a river
        :param edge: Edge
        :return: Boolean
        """
        for r in self.rivers_sources:
            while r.next is not None:
                if r.edge == edge:
                    return True
                r = r.next
        return False

    def find_river(self, x, y):
        """ Finds river segments at an hex's x and y coordinates. Returns a list of EdgeSides
            representing where the river segments are """
        seg = []
        for s in self.rivers:
            if s.x == x and s.y == y:
                seg.append(s.side)
        return seg