Return

Author: primal-coder

.idea/grid-engine.iml

@@ -1,4 +1,12 @@
-from . import _grid as Grid
-from . import _blueprint as Blueprint
-from . import _cell as Cell
-from . import _grid_object as GridObject
+from . import _grid as grid
+from . import _blueprint as blueprint
+from . import _cell as cell
+from . import _grid_object as grid_object
+
+def create_grid(cell_size=None, dimensions=None):
+    if cell_size is None:
+        cell_size = 1
+    if dimensions is None:
+        dimensions = (1000, 1000)
+    g = grid.Grid(cell_size=cell_size, dimensions=dimensions)
+    return g

.idea/misc.xml

@@ -1,6 +1,9 @@
+import time
 import logging
 from functools import wraps
 
+date = time.strftime('%Y-%m-%d', time.localtime())
+
 logging.addLevelName(44, 'GRIDENGINE')
 logger = logging.getLogger('GRIDENGINE')
 
@@ -9,7 +12,7 @@ def gridengine(message):
     logger.log(44, message)
 
 
-file_handler = logging.FileHandler('gridengine.log', 'w')
+file_handler = logging.FileHandler(f'logs/{date}.log', 'a')
 file_handler.setLevel(44)
 file_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(module)s - %(message)s'))
 logger.addHandler(file_handler)

grid_engine/8d564/grid.png

@@ -1,4 +1,4 @@
-from grid_engine import Blueprint, Grid
+from grid_engine import blueprint, grid
 import argparse
 import os
 import sys
@@ -44,33 +44,33 @@ def print(*args):
         raise FileNotFoundError(f'File {args.blueprint} does not exist')
     print(f'Loading blueprint from {args.blueprint} ...')
     try:
-        blueprint = Blueprint.load_blueprint(f'{blueprints}{args.blueprint}.pkl',  Blueprint.TerrainGridBlueprint)
+        blueprint = blueprint.load_blueprint(f'{blueprints}{args.blueprint}.pkl',  blueprint.TerrainGridBlueprint)
     except Exception:
-        blueprint = Blueprint.load_blueprint(f'{blueprints}{args.blueprint}.pkl',  Blueprint.BaseGridBlueprint)
+        blueprint = blueprint.load_blueprint(f'{blueprints}{args.blueprint}.pkl',  blueprint.BaseGridBlueprint)
     print('Success! Blueprint loaded.')
 else:
     if args.rows*args.columns > 1000000:
         print(f'{colorama.Fore.RED}WARNING{colorama.Fore.RESET}: The provided parameters will generate a grid composed of {colorama.Fore.LIGHTWHITE_EX}{round((args.rows*args.columns)/1000000, 1)} million{colorama.Fore.RESET} cells. \nThis will consume a significant amount of memory/resources/time. \nIf you have limited amount of memory this could cause your system to hang or crash. \nIf you understand the risks, continue by pressing {colorama.Fore.LIGHTGREEN_EX}ENTER{colorama.Fore.RESET}. Otherwise, press {colorama.Fore.LIGHTRED_EX}CTRL+C{colorama.Fore.RESET} to exit.')
         input()
     print(f'Generating blueprint with cell size {args.size}, {args.rows} rows and {args.columns} columns. Total_cells: {args.rows*args.columns} ...')
-    blueprint = Blueprint.TerrainGridBlueprint(cell_size=args.size, grid_dimensions=(args.columns*args.size, args.rows*args.size), noise_scale=args.noise_scale, noise_octaves=args.noise_octaves, noise_roughness=args.noise_roughness)
-    print(f'Success! Blueprint generated. Dimensions: {blueprint.grid_dimensions}')
+    bp = blueprint.TerrainGridBlueprint(cell_size=args.size, grid_dimensions=(args.columns*args.size, args.rows*args.size), noise_scale=args.noise_scale, noise_octaves=args.noise_octaves, noise_roughness=args.noise_roughness)
+    print(f'Success! Blueprint generated. Dimensions: {bp.grid_dimensions}')
 
 print('Building grid from blueprint ...')
-grid = Grid.Grid(blueprint=blueprint, with_terrain=True)
+g = grid.Grid(gblueprint=bp, with_terrain=True)
 print('Success! Grid generated.')
 
 if args.save:
     print('Pickling grid ...')
-    Grid.save_grid(grid=grid)
+    grid.save_grid(grid=g)
     print('Success!')
     print('Pickling blueprint ...')
-    Blueprint.save_blueprint(blueprint=blueprint)
+    blueprint.save_blueprint(blueprint=bp)
     print('Success!')
 
 if args.ascii:
     print('Writing ascii to file ...')
-    with open(f'{saves_dir}{grid.grid_id[-5:]}/grid.txt', 'w') as f:
+    with open(f'{saves_dir}{g.grid_id[-5:]}/grid.txt', 'w') as f:
         rows = []
         string = ''
         for row in grid.rows:
@@ -81,13 +81,13 @@ def print(*args):
         f.write('\n'.join(rows))
     print('Success!')
 
-cdata = Grid.extract_cell_data(grid)
-cell_size = grid.cell_size
-grid_id = grid.grid_id[-5:]
-height = grid.blueprint.grid_height
-width = grid.blueprint.grid_width
+cdata = grid.extract_cell_data(g)
+cell_size = g.cell_size
+grid_id = g.grid_id[-5:]
+height = g.blueprint.grid_height
+width = g.blueprint.grid_width
 del blueprint
-del grid
+del g
 
 from grid_engine import _utility as utility
 

grid_engine/__init__.py

@@ -34,12 +34,12 @@ def print(*args):
 if args.output is not None:
     if not isinstance(args.output, str) or not args.output.endswith('.json'):
         raise ValueError('Output file name must be a string ending with .json')
-    if not os.listdir(f'{os.getcwd()}{os.sep}blueprint{os.sep}blueprints').count(args.output):
-        args.output = f'{os.getcwd()}{os.sep}blueprint{os.sep}blueprints{os.sep}{args.output}'
+    if not os.listdir(f'{os.getcwd()}{os.sep}grid_engine{os.sep}_blueprint{os.sep}blueprints').count(args.output):
+        args.output = f'{os.getcwd()}{os.sep}grid_engine{os.sep}_blueprint{os.sep}blueprints{os.sep}{args.output}'
     else:
         raise FileExistsError(f'File {args.output} already exists')
 else:
-    args.output = f'{os.getcwd()}{os.sep}src{os.sep}blueprint{os.sep}blueprints{os.sep}grid.json'
+    args.output = f'{os.getcwd()}{os.sep}grid_engine{os.sep}blueprint{os.sep}blueprints{os.sep}grid.json'
 
 if not args.size or not args.columns or not args.rows:
     raise ValueError('Invalid cell size, row count or column count')
@@ -68,4 +68,3 @@ def print(*args):
 json.dump(data, open(args.output, 'w'), indent=4)
 print(f'Grid written to {args.output}')
 print('Success!')
-        

grid_engine/__log__.py

@@ -0,0 +1,105 @@
+from uuid import uuid4
+
+class _AbstractRoom:
+    _grid_blueprint = None
+    _room_id = None
+    _room_name = None
+    _room_type = None
+    _room_dimensions = None
+    _room_position = None
+    _room_doors = None
+    _room_cells = None
+    _room_cell_data = None
+    
+    @property
+    def grid_blueprint(self):
+        return self._grid_blueprint
+    
+    @property
+    def room_id(self):
+        return self._room_id
+    
+    @room_id.setter
+    def room_id(self, value):
+        self._room_id = value
+        
+    @property
+    def room_name(self):
+        return self._room_name
+    
+    @room_name.setter
+    def room_name(self, value):
+        self._room_name = value
+        
+    @property
+    def room_type(self):
+        return self._room_type
+    
+    @room_type.setter
+    def room_type(self, value):
+        self._room_type = value
+        
+    @property
+    def room_dimensions(self):
+        return self._room_dimensions
+    
+    @room_dimensions.setter
+    def room_dimensions(self, value):
+        self._room_dimensions = value
+        
+    @property
+    def room_position(self):
+        return self._room_position
+    
+    @room_position.setter
+    def room_position(self, value):
+        self._room_position = value
+        
+    @property
+    def room_doors(self):
+        return self._room_doors
+    
+    @room_doors.setter
+    def room_doors(self, value):
+        self._room_doors = value
+        
+    @property
+    def room_cells(self):
+        return self._room_cells
+    
+    @room_cells.setter
+    def room_cells(self, value):
+        self._room_cells = value
+        
+    @property
+    def room_cell_data(self):
+        return self._room_cell_data
+    
+    @room_cell_data.setter
+    def room_cell_data(self, value):
+        self._room_cell_data = value
+        
+class BaseRoom(_AbstractRoom):
+    def __init__(
+        self, 
+        grid_blueprint, 
+        room_position: tuple[int, int], 
+        room_dimensions: tuple[int, int], 
+        room_id: str = None, 
+        room_name: str = None, 
+        room_type: str = None, 
+        room_doors: list[tuple[int, int]] = None, 
+        room_cells: list[tuple[int, int]] = None, 
+        room_cell_data: list[tuple[int, int]] = None
+    ):
+        self.grid_blueprint = grid_blueprint
+        self.room_position = room_position
+        self.room_dimensions = room_dimensions
+        self.room_id = room_id if room_id else uuid4().hex
+        self.room_name = room_name if room_name else f"Room {self.room_id[-4:]}"
+        self.room_type = room_type if room_type else "Generic"
+        self.room_doors = room_doors
+        self.room_cells = room_cells
+        self.room_cell_data = room_cell_data
+        
+class 

grid_engine/__main__.py

@@ -0,0 +1,80 @@
+import numpy as np
+import networkx as nx
+
+MIN_ROOM_WIDTH = 0.1
+MIN_ROOM_HEIGHT = 0.1
+MAX_ROOM_WIDTH = 0.6
+MAX_ROOM_HEIGHT = 0.3
+MIN_ROOM_COUNT = 0.5
+MAX_ROOM_COUNT = 0.75
+MAX_ROOM_AREA = 0.5
+MIN_ROOM_HALL_COUNT = 1
+MAX_ROOM_HALL_COUNT = 5
+
+def initialize_grid(row_count, col_count):
+    return np.zeros((row_count, col_count))
+
+def does_intersect(room_a, room_b):
+    return not (room_a[0] + room_a[2] + 3 < room_b[0] or room_a[0] > room_b[0] + room_b[2] + 3 or room_a[1] + room_a[3] + 3 < room_b[1] or room_a[1] > room_b[1] + room_b[3] + 3)
+
+def gen_count(dimensions, cell_size):                           # gen_count((100, 100), 1)
+    x_min = int((dimensions[0] // cell_size) * MIN_ROOM_COUNT)  # x_min = 50
+    y_min = int((dimensions[1] // cell_size) * MIN_ROOM_COUNT)  # y_min = 50
+    size_factor = int((dimensions[0] * MIN_ROOM_WIDTH))         # size_factor = 10
+    if x_min > y_min:                                           # if 50 > 50:
+        min_count = (x_min + (x_min - y_min))    #   min_count = 50 + (50 - 50) // 10 ~ 5
+    else:                                                       # else:  
+        min_count = (y_min + (y_min - x_min))    #   min_count = 50 + (50 - 50) // 10 ~ 5
+    x_max = int((dimensions[0] // cell_size) * MAX_ROOM_COUNT)  # x_max = 70
+    y_max = int((dimensions[1] // cell_size) * MAX_ROOM_COUNT)  # y_max = 70
+    if x_max > y_max:                                           # if 70 > 70:     
+        max_count = x_max + (x_max - y_max)      #   max_count = 70 + (70 - 70) // 10 ~ 7
+    else:                                                       # else:        
+        max_count = y_max + (y_max - x_max)      #   max_count = 70 + (70 - 70) // 10 ~ 7
+    return np.random.randint(min_count, max_count) // 10              # return random.randint(5, 7)
+
+def gen_room_coords(grid):
+    min_room_width = int(grid.shape[1] * MIN_ROOM_WIDTH)
+    min_room_height = int(grid.shape[0] * MIN_ROOM_HEIGHT)
+    max_room_width = int(grid.shape[1] * MAX_ROOM_WIDTH)
+    max_room_height = int(grid.shape[0] * MAX_ROOM_HEIGHT)
+    room_x = np.random.randint(3, grid.shape[1] - max_room_width -3)
+    room_y = np.random.randint(3, grid.shape[0] - max_room_height - 3)
+    room_width =  np.random.randint(min_room_width, max_room_width)
+    room_height = np.random.randint(min_room_height, max_room_height)
+    room_area = room_width * room_height
+    max_room_area = int(grid.shape[0] * grid.shape[1] * MAX_ROOM_AREA)
+    if room_area > max_room_area:
+        excess = room_area - max_room_area
+        room_width -= excess // room_height
+    return room_x, room_y, room_width, room_height    
+    
+def generate_rooms(room_count, grid):
+    rooms = []
+    while len(rooms) < room_count:
+        new_room = gen_room_coords(grid)
+        if not any(does_intersect(new_room, room) for room in rooms):
+            rooms.append(new_room)
+    return rooms
+
+def find_rooms_edges(rooms, grid):
+    for room in rooms:
+        grid[room[1]:room[1]+room[3], room[0]:room[0]+room[2]] = 1
+        grid[room[1]:room[1]+1, room[0]:room[0]+room[2]] = 2  # Top edge
+        grid[room[1]+room[3]-1:room[1]+room[3], room[0]:room[0]+room[2]] = 2  # Bottom edge
+        grid[room[1]:room[1]+room[3], room[0]:room[0]+1] = 2  # Left edge
+        grid[room[1]:room[1]+room[3], room[0]+room[2]-1:room[0]+room[2]] = 2  # Right edge
+    return grid
+                    
+def generate_floorplan(cell_size: int = None, dimensions: tuple[int, int] = None):
+    grid = initialize_grid(dimensions[1] // cell_size, dimensions[0] // cell_size)
+    room_count = gen_count(dimensions, cell_size)
+    rooms = generate_rooms(room_count, grid)
+    grid = find_rooms_edges(rooms, grid)
+    return grid
+
+def print_floorplan(floorplan):
+    for row in floorplan:
+        print(''.join(str(int(cell)) for cell in row))
+    print()
+