maeves-ecosphere 0.1.2__tar.gz

maeves_ecosphere-0.1.2/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: maeves-ecosphere
+Version: 0.1.2
+Summary: A tile-based procedural ecosystem simulation, with an object component system.
+Author: MolassesLover

maeves_ecosphere-0.1.2/README.md

@@ -0,0 +1,108 @@
+# Maeve's Ecosphere
+
+<p><a href="https://ko-fi.com/molasses"><img src="https://img.shields.io/badge/donate-kofi-blue?style=for-the-badge&amp;logo=ko-fi&amp;color=e57578&amp;logoColor=FFFFFF&amp;labelColor=262a35" alt="Ko-Fi"></a>
+<a href="https://www.patreon.com/molasseslover"><img src="https://img.shields.io/badge/donate-patreon-blue?style=for-the-badge&amp;logo=patreon&amp;color=e57578&amp;logoColor=FFFFFF&amp;labelColor=262a35" alt="Patreon"></a> 
+
+This is a simple procedural cellular automata simulation resembling an ecosystem. 
+I made this, in my boredom, to toy around with during a lengthy 
+[PEM](https://en.wikipedia.org/wiki/Post-exertional_malaise) flare-up.
+
+The project makes use of rudimentary ECS-inspired framework, which makes use 
+of Python's dictionaries to manage data. Every tile (cell) is an object which 
+may contain another object as its `occupant`. These objects are referred to 
+as `SimulationObject`s and are this project's (much more bloated) equivalent
+to entities. Every `SimulationObject` contains a list of components, stored as
+dictionaries. Every component dictionary contains a callback function, which 
+serves as a system instance, as you'd see in a project using a conventional
+ECS architecture. Lastly, `SimulationObject`s also contain a `component_data` 
+dictionary which stores data accessed by components, straying from real 
+ECS implementations where data is stored directly inside of components.
+
+## Preview
+
+Below is a screenshot of the simulation after about 1h30m:
+
+![A screenshot of the Maeve's Ecosphere project depicting various tiles, each one depicting either a tree, grass, mushroom, or an isopod.](/docs/img/screenshot.png)
+
+Below is a brief glimpse at the early stage of a simulation:
+
+![A looping GIF video depicting the ecosphere, with various isopods foraging, and some vegetation growing.](/docs/img/preview.gif)
+
+If you'd like a more extensive preview, take a look at this
+[YouTube video](https://youtu.be/FK47rwov3aU).
+
+## Features 
+
+- Tiles which may be occupied by simulated objects
+- Simulated objects which may:
+    - Forage to other tiles.
+    - Consume other objects.
+    - Starve to death if too hungry.
+    - Produce objects in neighbouring tiles by:
+        - Reproducing with partner objects.
+        - Propogating themselves on their own.
+    - Age into different life stages.
+    - Die after reaching a certain age.
+    - Decompose after death.
+    - Affect the nutrition of a tile on birth or death.
+
+### Organisms
+#### Trees
+Trees take a significant amount of time to age into adulthood, and
+consequently encroach on surrounding organisms over time.
+
+#### Grass
+Grass has a very short lifespan, and serves as the initial food source for
+animals.
+
+#### Mushrooms
+Mushrooms take a long time to reach adulthood, spread prior to adulthood, and
+serve as the main food source for animals.
+
+#### Isopods
+Isopods forage the map, eating and mating with partner isopods when they can.
+
+## Cloning
+This project makes use of the [Git LFS](https://git-lfs.com/) extension, please
+make sure to install it prior to cloning.
+
+```sh
+➜ git lfs install
+```
+
+Already cloned the repository before setting Git LFS up? After you've 
+installed Git LFS, these commands should download all Git LFS files.
+
+```sh
+➜ git lfs fetch --all
+➜ git lfs pull
+➜ git lfs checkout
+```
+
+## Credits
+Image assets under the [`res/img/`](res/img) directory are taken from or 
+derivations of Pierre Vandermaesen' 1-bit asset pack,
+found [here](https://pierre-vandermaesen.itch.io/1-bit-16x16-asset-packs).
+
+## Running & Installing
+### Nix
+
+The recommended installation route is with use of Nix. This project provides a Nix 
+flake which can be installed via Home Manager, your NixOS configuration, and
+a plethora of other solutions which support Nix flakes.
+
+Alternatively the project can simply be run without installation using the following command:
+
+```sh
+➜ nix build .; ./result/result/bin/maeves-ecosphere
+```
+
+### Python
+
+Installation is required to run this project without Nix.
+
+```sh
+➜ pip install pygame cython
+➜ pip install .
+➜ python -m mecosphere.cli
+```

maeves_ecosphere-0.1.2/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "maeves-ecosphere"
+version = "0.1.2"
+description = "A tile-based procedural ecosystem simulation, with an object component system."
+
+authors = [
+    {name = "MolassesLover"}
+]
+
+[project.scripts]
+maeves-ecosphere = "mecosphere:cli.main"
+
+[build-system]
+requires = ["setuptools", "cython"]
+
+[tool.setuptools]
+ext-modules = [
+  { name = "mecosphere", sources = [
+    "src/mecosphere/application.py",
+    "src/mecosphere/components.py",
+    "src/mecosphere/simulation.py",
+    "src/mecosphere/tilemap.py"
+  ] }
+]

maeves_ecosphere-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

maeves_ecosphere-0.1.2/src/maeves_ecosphere.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: maeves-ecosphere
+Version: 0.1.2
+Summary: A tile-based procedural ecosystem simulation, with an object component system.
+Author: MolassesLover

maeves_ecosphere-0.1.2/src/maeves_ecosphere.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/maeves_ecosphere.egg-info/PKG-INFO
+src/maeves_ecosphere.egg-info/SOURCES.txt
+src/maeves_ecosphere.egg-info/dependency_links.txt
+src/maeves_ecosphere.egg-info/entry_points.txt
+src/maeves_ecosphere.egg-info/top_level.txt
+src/mecosphere/__init__.py
+src/mecosphere/application.py
+src/mecosphere/cli.py
+src/mecosphere/components.py
+src/mecosphere/simulation.py
+src/mecosphere/tilemap.py

maeves_ecosphere-0.1.2/src/maeves_ecosphere.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

maeves_ecosphere-0.1.2/src/maeves_ecosphere.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+maeves-ecosphere = mecosphere:cli.main

maeves_ecosphere-0.1.2/src/maeves_ecosphere.egg-info/top_level.txt

@@ -0,0 +1 @@
+mecosphere

maeves_ecosphere-0.1.2/src/mecosphere/__init__.py

@@ -0,0 +1 @@
+from . import *

maeves_ecosphere-0.1.2/src/mecosphere/application.py

@@ -0,0 +1,356 @@
+import argparse
+import sys
+import random
+import time
+
+import pygame
+
+from mecosphere import components
+from mecosphere.simulation import *
+from mecosphere.tilemap import *
+
+
+def arguments_create() -> Namespace:
+    argument_parser = argparse.ArgumentParser(prog="Maeve's Ecosphere")
+    argument_parser.add_argument(
+        "-c",
+        "--cycles",
+        type=int,
+        help="Limit simulation to a number of cycles.",
+    )
+    argument_parser.add_argument(
+        "-x",
+        "--width",
+        default=64,
+        type=int,
+        help="Width in tiles, this value is multiplied by 16 for the display window's width.",
+    )
+    argument_parser.add_argument(
+        "-y",
+        "--height",
+        default=36,
+        type=int,
+        help="Height in tiles, this value is multiplied by 16 for the display window's height.",
+    )
+    argument_parser.add_argument(
+        "-z",
+        "--headless",
+        action="store_true",
+        help="Height in tiles, this value is multiplied by 16 for the display window's height.",
+    )
+    arguments = argument_parser.parse_args()
+
+    return arguments
+
+
+class ApplicationSettings:
+    def __init__(self):
+        self.arguments = arguments_create()
+
+        if self.arguments.cycles:
+            self.cycles: int = self.arguments.cycles
+        else:
+            self.cycles = -1
+
+        self.headless: bool = self.arguments.headless
+        self.height: int = self.arguments.height
+        self.width: int = self.arguments.width
+
+
+class EcosphereApplication:
+    def __init__(self):
+        self.should_run = True
+        self.should_simulate = True
+
+        self.application_settings = ApplicationSettings()
+
+        if not self.application_settings.headless:
+            pygame.init()
+
+            self.pygame_display = pygame.display.set_mode(
+                (
+                    self.application_settings.width * 16,
+                    self.application_settings.height * 16,
+                )
+            )
+
+            if not self.application_settings.headless:
+                self.tile_dirt = pygame.image.load("res/img/dirt.bmp").convert()
+
+        self.ecosphere = Ecosphere(self.application_settings)
+
+        self.initialize()
+
+    def tiles_render(self):
+        col_index = 0
+        row_index = 0
+
+        for collumn in self.ecosphere.map:
+            for row in collumn:
+                tile = self.ecosphere.map[col_index][row_index]
+
+                self.pygame_display.blit(
+                    self.tile_dirt, (row_index * 16, col_index * 16)
+                )
+
+                if tile.occupant:
+                    self.pygame_display.blit(
+                        tile.occupant.image, (row_index * 16, col_index * 16)
+                    )
+
+                row_index += 1
+
+            row_index = 0
+            col_index += 1
+
+    def run(self):
+        cycles: int = 0
+
+        print("Running application!")
+
+        try:
+            while self.should_run:
+                self.pygame_display.fill((0, 0, 0))
+
+                for event in pygame.event.get():
+                    if event.type == pygame.QUIT:
+                        self.should_run = False
+
+                if self.should_simulate:
+                    if self.ecosphere.update() == 1:
+                        self.should_simulate = False
+                    elif not self.application_settings.cycles == -1:
+                        if cycles >= self.application_settings.cycles:
+                            self.should_simulate = False
+                            self.should_run = False
+
+                    cycles += 1
+
+                    print(f"Simulation cycle {cycles}\r", end="")
+
+                    self.tiles_render()
+
+                    pygame.display.flip()
+
+                # time.sleep(0.1666)
+        except KeyboardInterrupt:
+            print(f"Simulation cycle {cycles}\r", end="")
+            self.should_simulate = False
+            self.should_run = False
+
+        print(f"Exited application after {cycles-1} cycles.")
+
+        pygame.quit()
+
+    def run_headless(self):
+        cycles: int = 0
+
+        print("Running application in headless mode!")
+
+        try:
+            while self.should_run:
+                if self.should_simulate:
+                    if self.ecosphere.update() == 1:
+                        self.should_simulate = False
+                    elif not self.application_settings.cycles == -1:
+                        if cycles >= self.application_settings.cycles:
+                            self.should_simulate = False
+                            self.should_run = False
+
+                    cycles += 1
+
+                    print(f"Simulation cycle {cycles}\r", end="")
+
+        except KeyboardInterrupt:
+            print(f"Simulation cycle {cycles}\r", end="")
+            self.should_run = False
+
+        print(f"Exited application after {cycles-1} cycles.")
+
+    def start(self):
+        if not self.application_settings.headless:
+            self.run()
+        else:
+            self.run_headless()
+
+    def initialize(self):
+        # Propogation
+        print("Propogating ecosphere...")
+
+        propogated_map = self.ecosphere.map.copy()
+
+        for tile, col_index, row_index in ecosphere_map_yield_tile(
+            self.ecosphere.map,
+            width=self.application_settings.width,
+            height=self.application_settings.height,
+        ):
+            tile = propogated_map[col_index][row_index]
+
+            if tile == 1:
+                new_tree = SimulationObject(
+                    components=[],
+                    domain="flora",
+                    age_maximum=random.randint(1825, 7250),
+                    name="tree",
+                    species="tree",
+                    images={"image_egg": "seed"},
+                    position_range_width=self.application_settings.width,
+                    position_range_height=self.application_settings.height,
+                    headless=self.application_settings.headless,
+                    component_data={
+                        "Aging": {
+                            "is_egg": False,
+                            "is_baby": False,
+                            "age_baby": 180,
+                            "age_adult": 356,
+                        },
+                        "ReproducingAsexually": {
+                            "rate_percentage": 50,
+                            "while_baby": False,
+                        },
+                    },
+                    position=[col_index, row_index],
+                )
+
+                new_tree.components.append(components.component_age)
+                new_tree.components.append(components.component_reproduce_asexual)
+
+                new_tree.decomposition_maximum = 1000
+
+                propogated_map[col_index][row_index] = Tile(
+                    occupant=new_tree,
+                    nutritious=False,
+                    contaminated=False,
+                    pos_x=col_index,
+                    pos_y=row_index,
+                )
+
+                self.ecosphere.simulation_objects.append(new_tree)
+            elif tile >= 2 and tile < 5:
+                new_tree = SimulationObject(
+                    components=[],
+                    domain="flora",
+                    age_maximum=random.randint(120, 270),
+                    name="grass",
+                    species="grass",
+                    position_range_width=self.application_settings.width,
+                    position_range_height=self.application_settings.height,
+                    headless=self.application_settings.headless,
+                    images={"image_egg": "seed"},
+                    component_data={
+                        "Aging": {
+                            "is_egg": False,
+                            "is_baby": False,
+                            "age_baby": 5,
+                            "age_adult": 15,
+                        },
+                        "ReproducingAsexually": {
+                            "rate_percentage": 95,
+                            "while_baby": True,
+                        },
+                    },
+                    position=[col_index, row_index],
+                )
+
+                new_tree.components.append(components.component_age)
+                new_tree.components.append(components.component_reproduce_asexual)
+
+                propogated_map[col_index][row_index] = Tile(
+                    occupant=new_tree,
+                    nutritious=False,
+                    contaminated=False,
+                    pos_x=col_index,
+                    pos_y=row_index,
+                )
+
+                self.ecosphere.simulation_objects.append(new_tree)
+            elif tile == 5:
+                new_tree = SimulationObject(
+                    components=[],
+                    domain="fungus",
+                    age_maximum=random.randint(1500, 3000),
+                    name=f"mushroom",
+                    species="mushroom",
+                    position_range_width=self.application_settings.width,
+                    position_range_height=self.application_settings.height,
+                    headless=self.application_settings.headless,
+                    images={"image_egg": "seed"},
+                    component_data={
+                        "Aging": {
+                            "is_egg": False,
+                            "is_baby": False,
+                            "age_baby": 500,
+                            "age_adult": 1000,
+                        },
+                        "ReproducingAsexually": {
+                            "rate_percentage": 90,
+                            "while_baby": True,
+                        },
+                    },
+                    position=[col_index, row_index],
+                )
+
+                new_tree.components.append(components.component_age)
+                new_tree.components.append(components.component_reproduce_asexual)
+
+                propogated_map[col_index][row_index] = Tile(
+                    occupant=new_tree,
+                    nutritious=False,
+                    contaminated=False,
+                    pos_x=col_index,
+                    pos_y=row_index,
+                )
+
+                self.ecosphere.simulation_objects.append(new_tree)
+            else:
+                propogated_map[col_index][row_index] = Tile(
+                    occupant=None,
+                    nutritious=False,
+                    contaminated=False,
+                    pos_x=col_index,
+                    pos_y=row_index,
+                )
+
+            row_index += 1
+
+        row_index = 0
+        col_index += 1
+
+        self.ecosphere.map = propogated_map
+
+        for i in range(50):
+            isopod = SimulationObject(
+                components=[],
+                domain="fauna",
+                age_maximum=random.randint(913, 1825),
+                name=f"isopod {i}",
+                species="isopod",
+                position_range_width=self.application_settings.width,
+                position_range_height=self.application_settings.height,
+                headless=self.application_settings.headless,
+                component_data={
+                    "Eating": {
+                        "diet": ["grass", "mushroom"],
+                        "hunger": 0,
+                        "hunger_max": 120,
+                    },
+                    "Aging": {
+                        "is_egg": True,
+                        "is_baby": False,
+                        "age_baby": 30,
+                        "age_adult": 60,
+                    },
+                },
+                images={"image_baby": "isopod-baby"},
+            )
+
+            if not self.application_settings.headless:
+                isopod.image = isopod.image_baby
+
+            isopod.components.append(components.component_forage)
+            isopod.components.append(components.component_eat)
+            isopod.components.append(components.component_age)
+            isopod.components.append(components.component_reproduce_sexual_direct)
+
+            self.ecosphere.simulation_objects.append(isopod)
+            self.ecosphere.map[isopod.position[0]][isopod.position[1]].occupant = isopod

maeves_ecosphere-0.1.2/src/mecosphere/cli.py

@@ -0,0 +1,31 @@
+#!/usr/local/bin/env python3
+
+"""
+A simple ecosphere simulator I made while bored and sick.
+"""
+
+import sys
+import random
+import csv
+import time
+
+import pygame
+
+from mecosphere.application import *
+from mecosphere.simulation import *
+from mecosphere.tilemap import *
+
+
+def main():
+    """
+    The entrypoint for the script.
+    """
+
+    application = EcosphereApplication()
+
+    application.start()
+    application.should_run = False
+
+
+if __name__ == "__main__":
+    main()

maeves_ecosphere-0.1.2/src/mecosphere/components.py

@@ -0,0 +1,323 @@
+import sys
+import random
+import time
+import copy
+
+from mecosphere.simulation import *
+
+
+def create_descendant(
+    simobject_instance, new_position, _position_range_width, _position_range_height
+) -> SimulationObject:
+    simobject_descendant = SimulationObject(
+        name=f"{simobject_instance.name} Jr.",
+        species=simobject_instance.species,
+        domain=simobject_instance.domain,
+        components=copy.deepcopy(simobject_instance.components),
+        component_data=copy.deepcopy(simobject_instance.component_data),
+        age_maximum=simobject_instance.age_maximum,
+        images=simobject_instance.images,
+        position=new_position,
+        position_range_width=_position_range_width,
+        position_range_height=_position_range_height,
+        headless=simobject_instance.headless,
+    )
+
+    simobject_descendant.age_current = 0
+
+    return simobject_descendant
+
+
+def create_component(component_name, callback: callable, is_active=True) -> dict:
+    """
+    A simple constructor for components as dictionaries. This is not an ECS,
+    just borrowing the language.
+    """
+
+    component_dictionary = {
+        "name": component_name,
+        "active": is_active,
+        "callback": callback,
+    }
+
+    return component_dictionary
+
+
+def system_age(
+    simobject_instance, component_instance, ecosphere_map, application_settings
+):
+    if simobject_instance.is_dead:
+        return
+
+    age_current = simobject_instance.age_current
+    age_baby = simobject_instance.component_data["Aging"]["age_baby"]
+    age_adult = simobject_instance.component_data["Aging"]["age_adult"]
+
+    if age_current < age_baby:
+        if not application_settings.headless:
+            simobject_instance.image = simobject_instance.image_egg
+        simobject_instance.component_data["Aging"]["is_egg"] = True
+        simobject_instance.component_data["Aging"]["is_baby"] = False
+    elif age_current >= age_adult:
+        if not application_settings.headless:
+            simobject_instance.image = simobject_instance.image_default
+        simobject_instance.component_data["Aging"]["is_egg"] = False
+        simobject_instance.component_data["Aging"]["is_baby"] = False
+    elif age_current > age_baby and age_current < age_adult:
+        if not application_settings.headless:
+            simobject_instance.image = simobject_instance.image_baby
+        simobject_instance.component_data["Aging"]["is_egg"] = False
+        simobject_instance.component_data["Aging"]["is_baby"] = True
+    else:
+        if not application_settings.headless:
+            simobject_instance.image = simobject_instance.image_default
+
+
+def system_forage(
+    simobject_instance, component_instance, ecosphere_map, application_settings
+):
+    if "Aging" in simobject_instance.component_data:
+        if simobject_instance.component_data["Aging"]["is_egg"]:
+            return
+
+    position_old_tile = ecosphere_map[simobject_instance.position[0]][
+        simobject_instance.position[1]
+    ]
+
+    position_old_tile.occupant = simobject_instance
+
+    position_new = simobject_instance.position.copy()
+
+    position_new = [
+        position_new[0] + random.randint(-1, 1),
+        position_new[1] + random.randint(-1, 1),
+    ]
+
+    if position_new[0] > (application_settings.height - 1) or position_new[0] < 0:
+        return
+    elif position_new[1] > (application_settings.width - 1) or position_new[1] < 0:
+        return
+    else:
+        position_new_tile = ecosphere_map[position_new[0]][position_new[1]]
+
+    if not position_new_tile.occupant:
+        position_old_tile.occupant = None
+
+        simobject_instance.position = position_new
+
+        position_new_tile.occupant = simobject_instance
+
+
+def system_eat(
+    simobject_instance, component_instance, ecosphere_map, application_settings
+):
+    def eat():
+        if (
+            search_tile.occupant.species
+            in simobject_instance.component_data[component_instance["name"]]["diet"]
+        ):
+            search_tile.occupant.die()
+
+    hunger = simobject_instance.component_data[component_instance["name"]]["hunger"]
+    hunger_max = simobject_instance.component_data[component_instance["name"]][
+        "hunger_max"
+    ]
+
+    hunger += 1
+
+    if hunger >= hunger_max:
+        simobject_instance.die()
+        return
+    else:
+        simobject_instance.component_data[component_instance["name"]]["hunger"] = hunger
+
+    for search_tile, pos_x, pos_y in simulation_object_yield_tile_neighbour(
+        simobject_instance,
+        ecosphere_map,
+        width=application_settings.width,
+        height=application_settings.height,
+    ):
+        if search_tile.occupant:
+            if search_tile.occupant == simobject_instance:
+                return
+            elif search_tile.occupant.species == simobject_instance.species:
+                return
+            else:
+                eat()
+                simobject_instance.component_data[component_instance["name"]][
+                    "hunger"
+                ] = 0
+
+
+def is_hungry(_simobject_instance):
+    hungry = False
+
+    if "Eating" in _simobject_instance.component_data:
+        hunger = _simobject_instance.component_data["Eating"]["hunger"]
+        hunger_max = _simobject_instance.component_data["Eating"]["hunger_max"]
+
+        if hunger > (int(round(hunger_max / 2))):
+            hungry = True
+            return hungry
+
+    return hungry
+
+
+def system_reproduce_sexual_direct(
+    simobject_instance, component_instance, ecosphere_map, application_settings
+):
+    reproduction_partner = None
+
+    if "Aging" in simobject_instance.component_data:
+        if simobject_instance.component_data["Aging"]["is_egg"]:
+            return
+        elif simobject_instance.component_data["Aging"]["is_baby"]:
+            return
+
+    if is_hungry(simobject_instance):
+        return
+
+    for search_tile, pos_x, pos_y in simulation_object_yield_tile_neighbour(
+        simobject_instance,
+        ecosphere_map,
+        width=application_settings.width,
+        height=application_settings.height,
+    ):
+        if search_tile.occupant:
+            if not search_tile.occupant == simobject_instance:
+                if not search_tile.occupant.is_dead:
+                    reproduction_partner = search_tile.occupant
+                    break
+
+    if reproduction_partner:
+        if is_hungry(reproduction_partner):
+            return
+        else:
+            for search_tile, pos_x, pos_y in simulation_object_yield_tile_neighbour(
+                simobject_instance,
+                ecosphere_map,
+                width=application_settings.width,
+                height=application_settings.height,
+            ):
+                if (
+                    not search_tile.occupant
+                    and not search_tile.metadata["contaminated"]
+                ):
+                    baby = create_descendant(
+                        simobject_instance,
+                        new_position=[pos_x, pos_y],
+                        _position_range_width=application_settings.width,
+                        _position_range_height=application_settings.height,
+                    )  # Awww they're so alike
+
+                    baby.is_egg = True
+                    baby.is_baby = False
+
+                    if "Eating" in baby.component_data:
+                        baby_hunger_max = baby.component_data["Eating"]["hunger_max"]
+
+                        # Set the baby's hunger to 1/4 max hunger
+                        baby.component_data["Eating"]["hunger"] = int(
+                            round(baby_hunger_max / 4)
+                        )
+
+                    baby.age_current = 0
+
+                    ecosphere_map[pos_x][pos_y].occupant = baby
+
+                    if "Eating" in search_tile.occupant.component_data:
+                        search_tile.occupant.component_data["Eating"]["hunger"] += int(
+                            round(
+                                search_tile.occupant.component_data["Eating"][
+                                    "hunger_max"
+                                ]
+                                / 3
+                            )
+                        )
+                    if "Eating" in simobject_instance.component_data:
+                        simobject_instance.component_data["Eating"]["hunger"] += int(
+                            round(
+                                simobject_instance.component_data["Eating"][
+                                    "hunger_max"
+                                ]
+                                / 2
+                            )
+                        )
+
+
+def system_reproduce_asexual(
+    simobject_instance, component_instance, ecosphere_map, application_settings
+):
+    while_baby = simobject_instance.component_data["ReproducingAsexually"]["while_baby"]
+
+    rate_percentage = simobject_instance.component_data["ReproducingAsexually"][
+        "rate_percentage"
+    ]
+
+    rate_roll = random.randint(1, 100)
+
+    if rate_roll > (int(100 - round(rate_percentage))):
+        return
+
+    if not while_baby:
+        if "Aging" in simobject_instance.component_data:
+            if simobject_instance.component_data["Aging"]["is_egg"]:
+                return
+            if simobject_instance.component_data["Aging"]["is_baby"]:
+                return
+
+    for search_tile, pos_x, pos_y in simulation_object_yield_tile_neighbour(
+        simobject_instance,
+        ecosphere_map,
+        width=application_settings.width,
+        height=application_settings.height,
+    ):
+        if search_tile.occupant:
+            if search_tile.occupant == simobject_instance:
+                continue
+            elif not search_tile.occupant.is_dead:
+                continue
+            elif search_tile.occupant.species == simobject_instance.species:
+                continue
+            else:
+                clone = create_descendant(
+                    simobject_instance,
+                    new_position=[pos_x, pos_y],
+                    _position_range_width=application_settings.width,
+                    _position_range_height=application_settings.height,
+                )  # Propogation
+
+                clone.is_egg = True
+                clone.is_baby = False
+
+                clone.age_current = 0
+
+                ecosphere_map[pos_x][pos_y].occupant = clone
+
+                if search_tile.metadata["contaminated"]:
+                    ecosphere_map[pos_x][pos_y].metadata["contaminated"] = False
+
+
+component_forage: dict = create_component(
+    component_name="Foraging", callback=system_forage
+)
+
+component_eat: dict = create_component(
+    component_name="Eating",
+    callback=system_eat,
+)
+
+component_reproduce_sexual_direct: dict = create_component(
+    component_name="ReproducingSexuallyDirectly",
+    callback=system_reproduce_sexual_direct,
+)
+
+component_reproduce_asexual: dict = create_component(
+    component_name="ReproducingAsexually",
+    callback=system_reproduce_asexual,
+)
+
+component_age: dict = create_component(
+    component_name="Aging",
+    callback=system_age,
+)

maeves_ecosphere-0.1.2/src/mecosphere/simulation.py

@@ -0,0 +1,160 @@
+import sys
+import random
+import time
+
+import pygame
+
+from mecosphere.tilemap import *
+
+
+class Tile(object):
+    __slots__ = ("occupant", "metadata", "pos_x", "pos_y")
+
+    def __init__(self, occupant, nutritious, contaminated, pos_x, pos_y):
+        self.occupant: SimulationObject = occupant
+        self.pos_x = pos_x
+        self.pos_y = pos_y
+        self.metadata = self.metadata_create(nutritious, contaminated)
+
+    def metadata_create(self, nutritious=False, contaminated=False) -> dict:
+        metadata_dictionary = {"nutritious": nutritious, "contaminated": contaminated}
+
+        return metadata_dictionary
+
+
+class SimulationObject:
+    def __init__(
+        self,
+        name,
+        species,
+        domain,
+        position_range_width,
+        position_range_height,
+        components: list,
+        age_maximum=7,
+        component_data={},
+        images={},
+        position=[],
+        headless=False,
+    ):
+        self.age_current = 0
+        self.age_maximum = age_maximum
+        self.decomposition_current = 0
+        self.decomposition_maximum = int(round(age_maximum / 8))
+        self.components: list = components
+        self.images = images
+        self.name = name
+        self.species = species
+        self.position_range_width = position_range_width
+        self.position_range_height = position_range_height
+        self.headless = headless
+
+        if not position:
+            self.position = [
+                random.randint(1, self.position_range_height - 1),
+                random.randint(1, self.position_range_width - 1),
+            ]
+        else:
+            self.position = position
+
+        self.domain = domain
+        self.is_dead = False
+
+        if not self.headless:
+            self.image_default = pygame.image.load(f"res/img/{species}.bmp")
+            self.image_egg = pygame.image.load(f"res/img/egg.bmp")
+            self.image_dead = pygame.image.load(f"res/img/{species}-dead.bmp")
+            self.image_baby = self.image_default
+
+            if "image_baby" in images:
+                self.image_baby = pygame.image.load(
+                    f"res/img/{images['image_baby']}.bmp"
+                )
+            elif "image_egg" in images:
+                self.image_egg = pygame.image.load(f"res/img/{images['image_egg']}.bmp")
+
+            self.image = self.image_default
+
+        # `self.component_data`` is a dict of component names matched to any other child dict
+        # Example:
+        # { "Eating": { "diet": [ "grass", "mushroom" ] }, }
+
+        self.component_data = component_data
+
+    def die(self):
+        if not self.headless:
+            self.image = self.image_dead
+
+        self.is_dead = True
+
+
+class Ecosphere:
+    def __init__(self, _application_settings):
+        self.simulation_objects = (
+            []
+        )  # Set on every update call, do not change manually.
+        self.fauna: list = []
+        self.flora: list = []
+        self.bacteria: list = []
+        self.viruses: list = []
+        self.time = 0.0
+        self.application_settings = _application_settings
+        self.map = ecosphere_map_generate(self.application_settings)
+
+    def update(self) -> int:
+        if self.simulation_objects:
+            # Old list may contain out of bounds entitities
+            # We set self.simulation_objects to this new list in order to remove them
+            new_entities_list = []
+            living_entities_count = 0
+
+            for tile, col_index, row_index in ecosphere_map_yield_tile(
+                self.map,
+                width=self.application_settings.width,
+                height=self.application_settings.height,
+            ):
+                simulation_object = tile.occupant
+
+                if simulation_object:
+                    new_entities_list.append(simulation_object)
+
+                    if simulation_object.age_current > simulation_object.age_maximum:
+                        if not simulation_object.is_dead:
+                            simulation_object.die()  # Messed up, man. :C
+                        elif (
+                            simulation_object.decomposition_current
+                            >= simulation_object.decomposition_maximum
+                        ):
+                            if simulation_object.species == "fauna":
+                                self.map[col_index][row_index].contaminated = True
+
+                            self.map[col_index][row_index].occupant = None
+
+                            self.simulation_objects.remove(simulation_object)
+
+                            del simulation_object
+                        else:
+                            simulation_object.decomposition_current += 1
+                    else:
+                        living_entities_count += 1
+                        simulation_object.age_current += 1
+
+                        if (
+                            simulation_object.components
+                            and not simulation_object.is_dead
+                        ):
+                            for component in simulation_object.components:
+                                component["callback"](
+                                    simulation_object,
+                                    component,
+                                    self.map,
+                                    self.application_settings,
+                                )
+
+            self.simulation_objects = new_entities_list
+        else:
+            print("No more simulation objects, ending simulation.")
+
+            return 1
+
+        return 0

maeves_ecosphere-0.1.2/src/mecosphere/tilemap.py

@@ -0,0 +1,69 @@
+import sys
+import random
+import time
+
+import pygame
+
+
+def simulation_object_yield_tile_neighbour(
+    _simobject_instance, _ecosphere_map, width, height
+):
+    directions = [[-1, 0], [1, 0], [0, 1], [0, -1]]  # Left  # Right  # Up  # Down
+
+    for direction in directions:
+        check_position_x = _simobject_instance.position[0] + direction[0]
+        check_position_y = _simobject_instance.position[1] + direction[1]
+
+        if check_position_y > (width - 1):
+            check_position_y = width - 1
+        elif check_position_y < 0:
+            check_position_y = 0
+
+        if check_position_x > (height - 1):
+            check_position_x = height - 1
+        elif check_position_x < 0:
+            check_position_x = 0
+
+        tile = _ecosphere_map[check_position_x][check_position_y]
+
+        yield tile, check_position_x, check_position_y
+
+
+def ecosphere_map_yield_tile(ecosphere_map, width, height):
+    position_x = 0
+    position_y = 0
+
+    for collumn in range(height):
+        for row in range(width):
+            yield ecosphere_map[collumn][row], position_x, position_y
+
+            position_y += 1
+
+        position_y = 0
+        position_x += 1
+
+
+def ecosphere_map_generate(_application_settings) -> list:
+    print("Generating map...")
+    new_map = []
+    position_x = 0
+    position_y = 0
+
+    for collumn in range(_application_settings.height):
+        new_collumn = []
+
+        for row in range(_application_settings.width):
+            place_vegetation = bool(random.getrandbits(1))
+
+            if place_vegetation:
+                new_collumn.append(random.randint(1, 5))
+            else:
+                new_collumn.append(0)
+
+            position_y += 1
+
+        new_map.append(new_collumn)
+
+        position_x += 1
+
+    return new_map