*

Author: primal-coder

src/grid/__main__.py

@@ -8,6 +8,7 @@
 
 parser.add_argument('-i', '--interactive', action='store_true', help='Run an interactive session')
 parser.add_argument('-b', '--blueprint', dest='blueprint', type=str, default=None, help='Load a blueprint from a file')
+parser.add_argument('--ascii', action='store_true', help='Print the grid as ascii')
 parser.add_argument('-l', '--load', dest='load', type=str, default=None, help='Load a grid from a file')
 parser.add_argument('-t', '--terrain', action='store_true', default=True, help='Whether to generate terrain with the grid.')
 parser.add_argument('-ns', '--noise-scale', dest='noise_scale', type=int, default=100, help='Noise scale')
@@ -24,6 +25,7 @@
 
 from .blueprint import *
 from .grid import *
+from .utility import *
 
 terrain_grids = f'{os.getcwd()}{os.sep}src{os.sep}grid{os.sep}terrain_grids{os.sep}'
 grids = f'{os.getcwd()}{os.sep}src{os.sep}grid{os.sep}grids{os.sep}'
@@ -55,52 +57,32 @@ def print(*args):
 print('Success! Grid generated.')
 
 if args.save:
-    print('Saving grid ...')
+    print('Pickling grid ...')
     save_grid(grid=grid)
     print('Success!')
-    print('Saving blueprint ...')
+    print('Pickling blueprint ...')
     Blueprint.save_blueprint(blueprint=blueprint)
     print('Success!')
 
-print('Generating grid image ...')
-print('Importing pillow ...')
-from PIL import Image, ImageDraw
-print('Success.')
-
-print('Creating raw image ...')
-image = Image.new('RGB', (grid.blueprint.grid_width, grid.blueprint.grid_height), (255, 255, 255))
-print('Creating draw object ...')
-draw = ImageDraw.Draw(image)
-print('Drawing cells ...')
-total = len(grid.cells.values())
-for count, (cell, info) in enumerate(grid.blueprint.dictGrid.items(), start=1):
-    print(f'Drawing cell {info["designation"]} ... {round((count/total)*100)}%', end='\r')
-    x = info['coordinates'][0]
-    y = info['coordinates'][1]
-    color = grid.blueprint.dictTerrain[cell]['color']
-    draw.rectangle((x, y, x+(args.size), y+(args.size)), fill=color)
-
-# def capture_grid_as_image(grid: Grid, output_path: str):
-#     window_width = grid.blueprint.grid_width
-#     window_height = grid.blueprint.grid_height
-
-#     # Create a larger window that can accommodate the entire grid
-#     window = pyglet.window.Window(width=window_width, height=window_height)
-
-#     @window.event
-#     def on_draw():
-#         window.clear()
-#         grid.grid_batch.draw()
-
-#         # Capture the grid as an image
-#         image = pyglet.image.get_buffer_manager().get_color_buffer()
-#         image.save(output_path)
-
-#         # Close the window after capturing the image
-#         pyglet.app.exit()
-
-#     pyglet.app.run()
-
-# Usage example
-image.save(f'{saves_dir}{grid.grid_id[-5:]}/grid.png')
+if args.ascii:
+    print('Writing ascii to file ...')
+    with open(f'{saves_dir}{grid.grid_id[-5:]}/grid.txt', 'w') as f:
+        rows = []
+        string = ''
+        for row in grid.rows:
+            for cell in row:
+                string += cell.terrain_char
+            rows.append(string)
+            string = ''
+        f.write('\n'.join(rows))
+    print('Success!')
+    
+cdata = extract_cell_data(grid)
+grid_id = grid.grid_id[-5:]
+height = grid.blueprint.grid_height
+width = grid.blueprint.grid_width
+delete_grid(grid)
+    
+generate_images((width, height), cdata, args.size, grid_id)
+    
 

src/grid/blueprint/grid_blueprint.py

@@ -41,7 +41,8 @@ def load_blueprint(num: int):
         'terrain':    [
                 'raw', 'int',
                 'str', 'color',
-                'cost_in', 'cost_out'
+                'cost_in', 'cost_out',
+                'char'
         ]
 }
 
@@ -312,6 +313,7 @@ def _set_base_terrain(self):
                 self.dictTerrain[cell]['color'] = OCEAN_BLUE
                 self.dictTerrain[cell]['cost_in'] = float('inf')
                 self.dictTerrain[cell]['cost_out'] = float('inf')
+                self.dictTerrain[cell]['char'] = '~'
                 self.dictGrid[cell]['passable'] = False
 
 

src/grid/blueprint/terrain_processing.py

@@ -170,6 +170,7 @@ def generate_terrain_dict(terrain_data_ds: type[np.ndarray], terrain_data_pn: ty
                 terrain_dict[cell]['color'] = info['color']
                 terrain_dict[cell]['cost_in'] = info['cost_in']
                 terrain_dict[cell]['cost_out'] = info['cost_out']
+                terrain_dict[cell]['char'] = info['char']
                 break
     return terrain_dict
 

src/grid/blueprint/terrains.json

@@ -5,84 +5,96 @@
             "int": 0,
             "color": "SNOW_WHITE",
             "cost_in": Infinity,
-            "cost_out": 10
+            "cost_out": 10,
+            "char": "X"
         },
         "MOUNTAIN_CRAG": {
             "raw_max": 0.15,
             "int": 0,
             "color": "CRAG_GREY",
             "cost_in": Infinity,
-            "cost_out": 5
+            "cost_out": 5,
+            "char": "|"
         },
         "MOUNTAIN_SIDE": {
             "raw_max": 0.18,
             "int": 1,
             "color": "SIDE_GREY",
             "cost_in": Infinity,
-            "cost_out": 5
+            "cost_out": 5,
+            "char": "/"
         },
         "MOUNTAIN_BASE": {
             "raw_max": 0.23,
             "int": 2,
             "color": "BASE_GREY",
             "cost_in": Infinity,
-            "cost_out": 0
+            "cost_out": 0,
+            "char": "-"
         },
         "MOUND": {
             "raw_max": 0.28,
             "int": 3,
             "color": "MOUND_GREY",
             "cost_in": 2,
-            "cost_out": 0
+            "cost_out": 0,
+            "char": "_"
         },
         "FOOTHILL": {
             "raw_max": 0.43,
             "int": 3,
             "color": "FOOTHILL_GREEN",
             "cost_in": 1,
-            "cost_out": 0
+            "cost_out": 0,
+            "char": " "
         },
         "GRASS0": {
             "raw_max": 0.448,
             "int": 4,
             "color": "GRASS_GREEN",
             "cost_in": 1,
-            "cost_out": 0
+            "cost_out": 0,
+            "char": " "
         },
         "GRASS1": {
             "raw_max": 0.482,
             "int": 4,
             "color": "PLAIN_GREEN",
             "cost_in": 0,
-            "cost_out": 1
+            "cost_out": 1,
+            "char": " "
         },
         "GRASS2": {
             "raw_max": 0.488,
             "int": 4,
             "color": "GRASS_GREEN",
             "cost_in": 1,
-            "cost_out": 0
+            "cost_out": 0,
+            "char": " "
         },
         "GRASS3": {
             "raw_max": 0.495,
             "int": 4,
             "color": "PLAIN_GREEN",
             "cost_in": 0,
-            "cost_out": 1
+            "cost_out": 1,
+            "char": " "
         },
         "SAND": {
             "raw_max": 0.517,
             "int": 5,
             "color": "SANDY_GREY",
             "cost_in": 1.25,
-            "cost_out": 1
+            "cost_out": 1,
+            "char": "."
         },
         "SEASHELL": {
             "raw_max": 0.519,
             "int": 6,
             "color": "SEASHELL_WHITE",
             "cost_in": 1.5,
-            "cost_out": 1
+            "cost_out": 1,
+            "char": ","
         }
     }
 }

src/grid/cell.py

@@ -354,6 +354,7 @@ def __init__(
                 self.terrain_raw = self.parentgrid.dictTerrain[self.designation]['raw']
                 self.terrain_int = self.parentgrid.dictTerrain[self.designation]['int']
                 self.terrain_color = self.parentgrid.dictTerrain[self.designation]['color']
+                self.terrain_char = self.parentgrid.dictTerrain[self.designation]['char']
 
             self.overlay_color = None
             self.stored_overlay_color = None

src/grid/grid.py

@@ -29,6 +29,7 @@
 from typing import Optional as _Optional, Union as _Union
 
 RIVER_BLUE = (18, 70, 132, 255)
+RIVERBANK_BROWN = (92, 45, 15, 255)
 
 saves_dir = '/devel/fresh/envs/grid-engine/src/grid/saves/'
 
@@ -62,6 +63,18 @@ def get_vector_direction(pointa, pointb):
     )
 
 
+def extract_cell_data(grid):
+    """Accepts a grid object and returns only the necessary data to draw the cells"""
+    cell_data = []
+    for c, cell in grid.cells.items.items():
+        cdata = [cell.x, cell.y, cell.terrain_color]
+        cell_data.append(cdata)
+    return cell_data
+
+def delete_grid(grid: Grid):
+    """Deletes the grid object from memory in order to avoid OOM events"""
+    del grid
+
 def save_grid(grid: Grid):
     import os
     os.chdir(f'{saves_dir}')
@@ -697,7 +710,7 @@ def generate_realistic_river(self, start_cell: Cell, end_cell: Cell):
             expanded_path = self.expand_river_path(path)
             # shaped_path = self.shape_river_path(expanded_path)
             for cell in expanded_path:
-                cell.terrain_str = 'river'
+                cell.terrain_str = 'RIVER'
                 cell.terrain_raw = 0.0
                 cell.terrain_int = 9
                 cell.terrain_color = RIVER_BLUE
@@ -712,37 +725,52 @@ def generate_realistic_river(self, start_cell: Cell, end_cell: Cell):
         else:
             print("No path found between the start and end cells.")
 
+    def get_river_banks(self):
+        for cell in self.cells.values():
+            if cell.terrain_str == 'river':
+                adjacent_cells = cell.adjacent
+                for adjacent_cell in adjacent_cells:
+                    adjacent_cell = self.cells[adjacent_cell]
+                    if adjacent_cell.terrain_str not in ['RIVER', 'OCEAN', 'SAND']:
+                        adjacent_cell.terrain_str = 'RIVERBANK'
+                        adjacent_cell.terrain_raw = 0.0
+                        adjacent_cell.terrain_int = 8
+                        adjacent_cell.terrain_color = RIVERBANK_BROWN
+                        self.dictTerrain[adjacent_cell.designation] = {
+                            'str': adjacent_cell.terrain_str, 
+                            'raw': adjacent_cell.terrain_raw, 
+                            'int': adjacent_cell.terrain_int, 
+                            'color': adjacent_cell.terrain_color, 
+                            'cost_in': 1, 
+                            'cost_out': 2
+                            }
 
     def get_river_by_walk(self, start_cell: Cell):
         river_cells = [start_cell]
         branch_cells = []
-        start_cell = self.cells[start_cell]
         direction = random.randint(0, 7)
-        for step in range(640):
-            direction = direction if step % 16 != 0 else abs((random.randint(0, 7)) - direction)
-            current_cell = start_cell if step == 0 else self.cells[river_cells[-1]]
-            adjacent_cells = current_cell.adjacent
+        for step in range(random.randint(960, 1496)):
+            direction = direction if step % 24 != 0 else abs((random.randint(0, 7)) - direction)
+            current_cell = self.cells[river_cells[-1]]
             if adjacent_cells := [
                 adjacent_cell
-                for adjacent_cell in adjacent_cells
+                for adjacent_cell in current_cell.adjacent
                 if self.cells[adjacent_cell].passable
             ]:
-                next_cell = adjacent_cells[direction % len(adjacent_cells)]
+                next_cell = adjacent_cells[(direction + (0 if step % 6 else random.randint(-2, 2))) % len(adjacent_cells)]
                 river_cells.append(next_cell)
-            if step >= 240:
+            if step >= 768:
                 # create branch and continue branch with each step
-                direction2 = direction + 1 if direction < 7 else direction - 1
+                direction2 = direction + 4 if direction < 3 else direction - 4
                 if not branch_cells:
-                    branch_cells.append(current_cell.adjacent[direction2 % len(current_cell.adjacent)])
-                else:
-                    adjacent_cells = self.cells[branch_cells[-1]].adjacent
-                    if adjacent_cells := [
-                        adjacent_cell
-                        for adjacent_cell in adjacent_cells
-                        if self.cells[adjacent_cell].passable
-                    ]:
-                        next_branch_cell = adjacent_cells[direction2 % len(adjacent_cells)]
-                        river_cells.append(next_branch_cell)
+                    branch_cells.append(current_cell.adjacent[(direction2 + (0 if step % 4 else random.randint(-2, 2))) % len(adjacent_cells)])
+                elif adjacent_cells := [
+                    adjacent_cell
+                    for adjacent_cell in self.cells[branch_cells[-1]].adjacent
+                    if self.cells[adjacent_cell].passable
+                ]:
+                    next_branch_cell = adjacent_cells[(direction2 + (0 if step % 6 else random.randint(-1, 1))) % len(adjacent_cells)]
+                    branch_cells.append(next_branch_cell)
 
         return [river_cells, branch_cells]
 
@@ -912,13 +940,21 @@ def get_bend_directions(heading, path_count):
 
 
     def set_rivers(self, river_count):
+        largest_land = 0
+        largest_size = 0
+        for i, landmass in self.landmasses.items():
+            landmass_size = len(landmass['landmass_cells'])
+            if landmass_size > largest_size:
+                largest_land = i
+                largest_size = landmass_size
         for _ in range(river_count):
-            landmass = self.landmasses[random.choice(list(self.landmasses.keys()))]
+            landmass = self.landmasses[largest_land]
             coastal_cells = landmass['coastal_cells']
             print('Building river ...')
             start, end = self.get_river_ends(coastal_cells)
             self.generate_realistic_river(start, end)
-            print('done')            
+        self.get_river_banks()
+        print('done')            
     # Define the _heuristic function
 
     def _heuristic(self, cella, cellb):