The foundational contract for every entity in the Genesis ecosystem starts
with matter.c. By inheriting this blueprint, any objectwhether injected by a
human, an AI, or evolved by the systemguarantees it can participate in the
genetic handshake.
Because our engine currently lacks a native string_contains() or Regex efun,
we can exploit the new explode() efun to read genomes. If we explode an
incoming string using a specific genetic symbol (like * for radiation) and the
resulting array size is greater than 1, we know the symbol was present.
Here is the base interface that defines the universal state and a default,
inert reaction.
/ tests/fixtures/matter.c
string genome;
string name;
int energy;

void set_identity(string n, string g, int e) {
    name = n;
    genome = g;
    energy = e;
}

string query_genome() { return genome; }
string query_name() { return name; }
int query_energy() { return energy; }

/ The universal genetic handshake. 
/ Child blueprints override this to define unique organic behavior.
void react(object source, string incoming) {
    int arr;
    
    // Default thermodynamic rule for dumb matter:
    // If the incoming genome contains "*", absorb it as ambient heat.
    arr = explode(incoming, "*");
    if (sizeof(arr) > 1) {
        energy = energy + 1;
    }
}

To see the asymmetric reaction model in action, a player or bot could
introduce an organic entity like algae.c. It inherits the base matter but
overrides the react() function to look for specific symbiotic or hostile
symbols, completely ignoring anything else.
/ tests/fixtures/algae.c
inherit "tests/fixtures/matter.c";

void setup() {
    // Algae's genetic string: "~" (water affinity) and "[A]" (organic
identifier)
    set_identity("Algae", "~~[A]~~", 10);
}

void react(object source, string incoming) {
    int arr;
    
    // 1. Check for Photosynthesis: "*~" (Light passing through water)
    arr = explode(incoming, "*~");
    if (sizeof(arr) > 1) {
        energy = energy + 5;
    }
    
    // 2. Check for Toxin: "X"
    arr = explode(incoming, "X");
    if (sizeof(arr) > 1) {
        energy = energy - 10;
        if (energy < 0) {
            destruct(this_object()); // Cell death
        }
    }
    
    // Anything else (like a rock's genome "[R]") is silently ignored. 
    // The algae doesn't have the receptors for it.
}

This architecture is completely decentralized. If I spawn a toxin.c object
with the genome "--X--", the engine never executes an attack() function. The
toxin simply broadcasts its string to the Algae, and the Algae's own react()
function decides that it takes damage.
To bring this ecosystem to life, we need an environment to hold them and
facilitate the broadcasts. Should we build the grid.c controller next, which
loops through a 2D array of these objects and forces adjacent cells to
exchange their genomes every tick?