Rejoice!

Author: primal-coder

README.md

@@ -1,36 +1,35 @@
-# grid-engine
+# grid_engine
 
 ## Description
 
-**gridengine** is a framework for generating and manipulating grids. It provides a number of classes and functions for generating and manipulating grids. Each grid is composed of [Cell](#Cell) objects and is defined by a [Blueprint](#Blueprint). A grid can be generated from a blueprint, loaded from a file, or created manually. It can also be pickled for later use. It can be rendered as a 2D image, an animated GIF or an ASCII string. Grids provide a number of relevant methods for pathfinding, cell manipulation, and more.
+**grid_engine** is a framework for generating and manipulating grids. It provides a number of classes and functions for generating and manipulating grids. Each grid is composed of [Cell](#Cell) objects and is defined by a [Blueprint](#Blueprint). A grid can be generated from a blueprint, loaded from a file, or created manually. It can also be pickled for later use. It can be rendered as a 2D image, an animated GIF or an ASCII string. Grids provide a number of relevant methods for pathfinding, cell manipulation, and more.
 
 ## Installation
 
-To install **gridengine**, run the following command:
+To install **grid_engine**, run the following command:
 
     ```bash
-    pip install grid_engine
+    pip install gridengine_framework
     ```
 
 ## Usage
 
-To use **gridengine** you can import any number of the submodules and utilize its respective features.
+To use **gridengine** you can import any number of the submodules and utilize its respective features or you can import the main module.
 
     ```python
-    import gridengine
-    from gridengine import grid
+    import grid_engine as ge
 
     # Create a grid
-    grid = grid.Grid(cell_size=10, grid_dimensions=(1000, 1000))
+    grid = ge.grid.Grid(cell_size=10, grid_dimensions=(1000, 1000))
 
     # Save a grid
-    grid.save_grid()
+    ge.grid.save_grid(grid)
 
     # Load a grid
-    loaded_grid = grid.Grid.load_grid(1)
+    loaded_grid = ge.grid.Grid.load_grid(1)
     ```
 
-grid-engine also provides a command line interface. To use it, run the following command:
+**grid_engine** also provides a command line interface. To use it, run the following command:
 
     ```bash
     python -m grid_engine --help
@@ -63,9 +62,9 @@ grid-engine also provides a command line interface. To use it, run the following
     #   -v, --verbose         Verbose output
     ```
 
-# Examples
+## Examples
 
-The following examples demonstrate the use of the grid-engine package.
+The following examples demonstrate the use of the **grid_engine** package.
 
 ### CLI
 
@@ -124,13 +123,14 @@ Will produce the following output:
 
 The following image is the result of the above command:
 
-![grid](grid_engine/_saves/8d564/grid.png)
+![grid](saves/cf1b9/grid.png)
+
 *The river generation algorithm is not perfect. I am currently working on improving it.*
 
 The above command will also produce the following files(Not included in the repository... That is, generate your own!):
 
-* `grid.8d564.pickle`: A pickled Grid object.
-* `blueprint.8d564.pickle`: A pickled TerrainGridBlueprint object.
+* `grid.cf1b9.pickle`: A pickled Grid object.
+* `blueprint.cf1b9.pickle`: A pickled TerrainGridBlueprint object.
 
     ```python
     import grid_engine

grid_engine/README.md

@@ -1,6 +1,6 @@
 # Grid
 
-The **Grid** submodule provides numerous classes and functions for generating and manipulating grids. Each grid is composed of [Cell](_cell/cell.py) objects and is defined by a [Blueprint](_blueprint/_grid_blueprint.py). A grid can be generated from a blueprint, loaded from a file, or created manually. It can also be pickled for later use. It cab be rendered as a 2D image, an animated GIF or an ASCII string. Grids provide a number of relevant methods for pathfinding, cell manipulation, and more.
+The **Grid** submodule provides numerous classes and functions for generating and manipulating grids. Each grid is composed of [Cell](_cell/_cell.py) objects and is defined by a [Blueprint](_blueprint/_grid_blueprint.py). A grid can be generated from a blueprint, loaded from a file, or created manually. It can also be pickled for later use. It cab be rendered as a 2D image, an animated GIF or an ASCII string. Grids provide a number of relevant methods for pathfinding, cell manipulation, and more.
 
 ## Usage
 
@@ -11,7 +11,7 @@ import gridengine
 from gridengine import Grid
 
 # Create a grid
-grid = Grid(cell_size=2, grid_dimensi1ons=(5000, 2500))
+grid = Grid(cell_size=2, grid_dimensi1ons=(1000, 1000))
 
 # Save a grid
 Grid.save_grid(grid)

grid_engine/__init__.py

@@ -2,6 +2,7 @@
 from . import _blueprint as blueprint
 from . import _cell as cell
 from . import _grid_object as grid_object
+# from . import _dungeon as dungeon
 
 def create_grid(cell_size=None, dimensions=None):
     if cell_size is None:

grid_engine/__main__.py

@@ -31,7 +31,7 @@
 
 args = parser.parse_args()
 
-saves_dir = f'{os.path.abspath(os.path.curdir)}grid_engine/_saves/'
+saves_dir = f'{os.path.abspath(os.path.curdir)}/saves/'
 
 if not args.verbose:
     def print(*args):
@@ -68,29 +68,30 @@ def print(*args):
     blueprint.save_blueprint(blueprint=bp)
     print('Success!')
 
+
+    
+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
+
+from grid_engine import _utility as utility
+        
 if args.ascii:
     print('Writing ascii to file ...')
-    with open(f'{saves_dir}{g.grid_id[-5:]}/grid.txt', 'w') as f:
+    with open(f'{saves_dir}{grid_id}/grid.txt', 'w') as f:
         rows = []
         string = ''
-        for row in grid.rows:
+        for row in g.rows:
             for cell in row:
                 string += cell.terrain_char
             rows.append(string)
             string = ''
         f.write('\n'.join(rows))
     print('Success!')
 
-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 g
 
-from grid_engine import _utility as utility
-    
 utility.generate_images((width, height), cdata, cell_size, grid_id, animate=args.animate)
-    
-

grid_engine/_blueprint/_grid_blueprint.py

@@ -368,7 +368,7 @@ def _init(self):
         self.array[:, :, 0] = self.dictGrid.values()
         if not self.with_terrain:
             self.dictTerrain = {
-                    cell: {'raw':  1, 'int': 1, 'str': 'GRASS', 'color': _COLORS['GRASS'], 'cost_in': 1, 'cost_out': 1,
+                    cell: {'raw':  1, 'int': 1, 'str': 'GRASS', 'color': _COLORS['GRASS_GREEN'], 'cost_in': 1, 'cost_out': 1,
                            'char': ''} for cell in self.cell_list}
 
     def _init_quadrants(self):

grid_engine/_blueprint/_grid_processing.py

@@ -123,6 +123,7 @@ def get_cell_coordinates(cell_size: int, row_count: int, col_count: int) -> List
         # Output: [(0, 0), (10, 0), (20, 0), (30, 0), (0, 10), (10, 10), (20, 10), (30, 10), (0, 20), (10, 20), (20, 20), (30, 20)]
         ```
     """
+    print(f'Getting cell coordinates')
     return [
         (
             abs(0 - ((num % col_count) * cell_size)),
@@ -173,7 +174,8 @@ def get_grid_dict(cell_strings: List[str], row_strings: List[str], col_strings:
             "col_index": col_strings.index(cell[-5:]),
             "coordinates": cell_coordinates[i],
             "quadrant_index": None,
-            "adjacent": []
+            "adjacent": [],
+            "passable": True
         } for i, cell in enumerate(cell_strings)
     }
 
@@ -269,6 +271,8 @@ def generate_adjacency(grid_dict: Dict[str, any], row_count: int, col_count: int
     h = row_count
     for cell, information in grid_dict.items():
         print(f'Progress: {information["cell_index"]}/{len(grid_dict)}', end='\r')
+        if information['cell_index'] == row_count * col_count - 1:
+            print('\nAdjacency generation complete.')
         n = information['cell_index']
         r = grid_dict[cell]['row_index']
         f = grid_dict[cell]['col_index']

grid_engine/_blueprint/_terrain_processing.py

@@ -11,6 +11,7 @@
     'OCEAN_BLUE': (16, 78, 139, 255),
     'BARREN_BROWN': (77, 88, 77, 255),
     'GRASS_GREEN': (84, 139, 84, 255),
+    'FOREST_GREEN': (55, 201, 99, 255),
     'PLAIN_GREEN': (90, 154, 90, 255),
     'FOOTHILL_GREEN': (82, 144, 78, 255),
     'GULCH_GREEN': (74, 130, 70, 255),

grid_engine/_cell/README.md

@@ -1,3 +1,151 @@
 # Cell
 
-The Cell class is debatably the most important element of grid-engine. It is integral in the creation of the grid, and is the main way to interact with the grid. The Cell class contains information, which independently is not very useful, but upon arrangement with other cells, can be used to create a whole world. 
+The Cell class is demonstrably the most important element of `grid-engine`. It is integral in the creation and interaction of the grid. The Cell class contains information which upon arrangement with other cells, can be used to create living world. Cells should never be instantiated directly, but rather through an instance of the `grid_engine.grid.Grid` object. Instances of Cell may then be accessed through said instance.
+
+## Base Properties
+
+The following properties are present in all cell objects:
+
+- `cell_index` (int): The index of the cell in the grid. This serves as a unique identifier for the cell. Cells are indexed from 0 to `grid.size - 1`. With the first cell, `a00001`(index 0) in the top left corner and the last cell, in the bottom right corner.
+- `x` (int): The x-coordinate of the cell.
+- `y` (int): The y-coordinate of the cell.
+- `coordinates` (tuple): The coordinates of the cell in the form `(x, y)`.
+- `designation` (str): The designation of the cell. (e.g., 'a00001', 'R0132', etc.)
+- `height` (int): The visual height of the cell.
+- `width` (int): The visual width of the cell.
+- `size` (int): The visual size of the cell.
+- `row` (list): The row in which the cell resides, represented as a list of `Cell` objects.
+- `row_name` (str): The name of the row in which the cell resides. (e.g., 'a', 'R', etc.)
+- `row_index` (int): The index of the row in which the cell resides.
+- `col` (list): The col(umn) in which the cell resides, represented as a list of `Cell` objects.
+- `col_name` (str): The name of the column in which the cell resides. (e.g., '00395')
+- `col_index` (int): The index of the column in which the cell resides.
+- `quadrant` (list): The quadrant in which the cell resides, represented as a list of `Cell` objects.
+- `quadrant_index` (int): The index of the quadrant in which the cell resides.
+- `adjacent` (list): A list of all the cells adjacent to the current cell.
+- `up` (Cell): The cell directly above the current cell.
+- `down` (Cell): The cell below the current cell.
+- `left` (Cell): The cell to the left of the current cell.
+- `right` (Cell): The cell to the right of the current cell.
+- `up_left` (Cell): The cell above and to the left of the current cell.
+- `up_right` (Cell): The cell above and to the right of the current cell.
+- `down_left` (Cell): The cell below and to the left of the current cell.
+- `down_right` (Cell): The cell below and to the right of the current cell.
+- `array` (numpy.ndarray): The cell and all its relevant properties in the form of a numpy array.
+- `cost_in` (int): The cost to enter the cell.
+- `cost_out` (int): The cost to exit the cell.
+
+## Secondary Properties
+
+The following properties are present in cell objects relating to terrain data:
+
+- `terrain_str` (str): The string representation of the terrain type (`GRASS`, `OCEAN`, etc.).
+- `terrain_raw` (float): The raw value of the terrain usually between 0 and 1, generated by a noise function.
+- `terrain_int` (int): The integer value of the terrain, corresponding to a specific terrain type.
+- `terrain_color` (tuple): The color of the terrain in RGB format, providing the grid is a graphical generation.
+- `terrain_char` (str): The ASCII character representing the terrain, in the event of a grid being rendered with `curses` or similar.
+- `terrain_shape` [DEPRECATED] (str): The shape of the object representing the cell/terrain. Will be removed in future versions.
+- `clearance_up` (int): The clearance above the cell (i.e., the distance between the cell and the nearest above cell that is not passable).
+- `clearance_down` (int): The clearance below the cell.
+- `clearance_left` (int): The clearance to the left of the cell.
+- `clearance_right` (int): The clearance to the right of the cell.
+- `clearance_x` (int): The clearance on the x-axis of the cell(i.e., left and right).
+- `clearance_y` (int): The clearance on the y-axis of the cell(i.e., up and down).
+- `in_region` (bool): Whether the cell is in any region.
+- `landmass_index`: The index of the landmass to which the cell belongs.
+- `body_of_water_index`: The index of the body of water to which the cell belongs.
+- `is_coastal`: Whether the cell is coastal, this includes the coast of oceans or lakes.
+
+## Tertiary Properties
+
+The following properties are related to the values stored in the `array` property. They are prefixed with the word `entry`.
+Accessing and modifying these properties will be reflected in the `array` property and vice versa. Most of these properties have convenient methods for accessing and modifying them. For example, the `add_object` method can be used to add an object to the cell, thereby modifying the `entry_object` property and the `array` property.
+
+- `entry` (array): A dictionary containing the base properties of the cell. This includes the following properties:
+  - `designation` (str)
+  - `cell_index` (int)
+  - `row_index` (int)
+  - `col_index` (int)
+  - `ooordinates` (tuple)
+  - `quadrant_index` (int)
+  - `adjacent` (list)
+  - `passable` (bool)
+- `entry_terrain` (dict): A dictionary containing the terrain information for the cell. This includes the following properties:
+  - `terrain_str` (str)
+  - `terrain_raw` (float)
+  - `terrain_int` (int)
+  - `terrain_color` (tuple)
+  - `terrain_char` (str)
+  - `terrain_shape` (str)
+- `entry_object` (dict): A dictionary containing the objects which may currently exist on the cell. This includes the following properties:
+  - `items` (dict)
+  - `obstructions` (dict)
+  - `structures` (dict)
+  - `features` (dict)
+  - `resources` (dict)
+  - `containers` (dict)
+  - `doors` (dict)
+  - `traps` (dict)
+  - `switches` (dict)
+- `entry_unit` (dict): A dictionary containing the units which may currently exist on the cell. This includes the following properties:
+  - `players` (dict)
+  - `npcs`  (dict)
+  - `monsters` (dict)
+  - `neutrals` (dict)
+  - `pets` (dict)
+  - `mounts`
+- `entry_zone` (dict): A dictionary containing the zones which may currently exist on the cell. This includes the following properties:
+  - `areas`
+  - `locales`
+  - `regions`
+  - `cities`
+  - `towns`
+  - `villages`
+- `entry_effect` (dict): A dictionary containing the effects which may currently exist on the cell. This includes the following properties:
+  - `weather`
+  - `lighting`
+  - `environment`
+  - `magic`
+- `entry_fow` (dict): A dictionary containing the fog of war information for the cell. This includes the following properties:
+  - `visibility`
+  - `explored`
+  - `seen`
+  - `hidden`
+
+## Methods
+
+- `__init__(self, x, y, designation, height, width, row=None, col=None, quadrant=None)`: The constructor for the Cell class.
+- `__repr__(self)`: The representation of the cell. For example, 'a00001'.
+- `add_object(self, grid_object)`: Adds an object to the cell.
+- `add_unit(self, unit)`: Adds a unit to the cell.
+- `add_zone(self, zone)`: Adds a zone to the cell.
+- `build(self, orientation)`: Constructs a wall-like grid structure on the cell in the specified orientation.
+- `dig(self)`: if the cell is unpassable, dig is meant to emulate the removal of said obstacle.
+- `get_diagonal(self, xaxis, yaxis, distance)`: Returns a list of cells that are diagonal to the current cell at a specified distance in a specified direction.
+- `get_groups(self)`: Returns a list of all the groups to which the cell belongs.
+- `get_region(self)`: Returns the region to which the cell belongs.
+- `get_clearance_zone(self)` (list): Returns a list of passable cells which surround the current cell.
+- `in_neighborhood(self, neighbor)`: Returns True if the cell is in the neighborhood of the specified cell.
+- `join_group(self, group)`: Adds the cell to the specified group.
+- `leave_group(self, group)`: Removes the cell from the specified group.
+- `on_construct(self)`: A method that is called when a construction is completed on the cell.
+- `on_destruct(self)`: A method that is called when a destruction is completed on the cell.
+- `on_divest(self)`: Sets the cell as unentitled. 
+- `on_entitle(self)`: Sets the cell as entitled.
+- `on_occupy(self)`: A method that is called when a cell becomes occupied.
+- `on_vacate(self)`: A method that is called when a cell is no longer occupied.
+- `recv_occupant(self, occupant)`: Receives an occupant signal from a GridEntity.
+- `remove_object(self, grid_object)`: Removes an object from the cell.
+- `remove_unit(self, unit)`: Removes a unit from the cell.
+
+## Usage
+
+```python
+import grid_engine as ge
+
+grid = ge.grid.Grid()
+
+cell = grid.random_cell()
+
+print(cell)
+```

grid_engine/_cell/__init__.py

@@ -1 +1 @@
-from .cell import Cell
+from ._cell import Cell