TEAM PERSONAL · GAME DEVELOPMENTDevelopment project

Project Seedling

A farming and genetics simulation where laboratory decisions influence plant growth, water consumption, yield and crop stability. The eight-gene genome and derived traits connect experimentation with the gameplay lifecycle.

Unity 6C#Universal Render PipelineNUnitAndroid
PSProject SeedlingFarming · Genetics · Experimentation
01 · GENETICS

How plant DNA controls farming

PYBGPYBG

Eight validated slots compose the wheat genome. Adjacent Y genes influence crop yield; B/G sequences activate an adaptation modifier. Trait calculations are deterministic and can be tested independently of the Unity scene.

02 · GAMEPLAY SYSTEMS

From laboratory to field

01

Genome validation

The domain model checks P, Y, B and G genes, preserves a rules version and returns a new genome when one slot is replaced.

02

Wheat trait calculation

The wheat evaluator computes growth duration, yield, water demand, stability and visual variants from the eight-gene sequence.

03

Farm lifecycle

Plots progress through Empty, Planted, Growing and Mature states; planting and harvest results are explicit enums and can be tested with an injected clock.

04

DNA lab interaction

Unity scene controllers connect input, selection, scissor-arm animation and the trait panel to the genetics state without mixing DNA rules into UI scripts.

05

Local saves and recovery

Progress is persisted to Unity’s application data directory. Failed reads do not overwrite invalid save files; backup recovery is a documented path.

06

Tests

Edit-mode NUnit tests cover genome immutability, trait evaluation, persistence, farm field operations and validation of DNA-laboratory workflows.

How this connects to gameplay: the genome is validated before the trait calculation is performed. The evaluator derives growth, yield and water requirements from the gene sequence. A farm plot moves between lifecycle states, so a harvest request should only succeed when its state allows it. Keeping the calculation in the C# domain layer lets edit-mode tests check outcomes without requiring the Unity scene to run.

Verified scope of the first playable slice

The game-vision and genetics specifications define a deliberately small Android prototype: one wheat crop, a fictional eight-segment genome and reproducible experimentation.

01

Eight-segment genome

Four colour-coded game genes represent Growth, Yield, Drought Resistance and Stability. The schema and rules version travel with a seed; these are fictional mechanics, not a real CRISPR or biological DNA model.

02

Deterministic evaluation

The same genome, crop data, rules version and environment should produce the same base traits. Balancing should expose trade-offs such as water demand versus yield, not arbitrary rarity rolls.

03

First playable loop

The roadmap targets a scissor-based editor, one test pot, visible growth and harvest results, seed catalogue and a simple offline selling loop on Android.

04

Later milestones

Farm plots, a fictional newspaper marketplace and economy tuning belong to later sprints. Asynchronous farms, visits and player trade are explicitly deferred.

Documentation: GitHub repository / project specification. The content describes documented behaviour or plans; deployment readiness is not inferred.

04 · EXPLORE

Project-specific previews

Static visualizations of documented systems, not screenshots from a released application.

Game system preview · illustrative

Eight-gene crop editor

GENETICS LAB / GENOME A-04
PYBGPYGB

A proposed editor presents individual positions in the genome; the code validates the replacement and evaluates crop traits.

PYBG
Game system preview · illustrative

Harvest and resource forecast

CROP EVALUATION / PREVIEW
Yield
78
Water
54
Stability
88
Growth
65

Derived crop traits can be displayed together so players compare harvest, growth time and water use before planting.

YieldWaterStabilityGrowth
Game flow preview · illustrative

Plot lifecycle and field states

FIELD PLOT / GROWTH TRACKING
·Empty
●Planted
♣Growing
✿Ready

Farm plots can expose their lifecycle explicitly so planting, update and harvest actions align with the tested state machine used in the domain layer.

EmptyPlantedGrowingMature
03 · ACTUAL SOURCE

Selected code and engineering decisions

Immutable genome edits

C#

The original genome stays unchanged; replacement returns a new validated instance.

Assets/_Project/Scripts/Core/Genetics.csSelected source excerpt
public Genome Replace(int index, char gene)
{
    if (index < 0 || index >= Length)
        throw new ArgumentOutOfRangeException(nameof(index));
    ValidateGene(gene);
    char[] edited = Sequence.ToCharArray();
    edited[index] = gene;
    return new Genome(new string(edited), RulesVersion);
}

Trait calculations from eight genes

C#

Adjacent gene sequences activate bonuses; the resulting crop characteristics are deterministic.

Assets/_Project/Scripts/Core/Genetics.csSelected source excerpt
bool highYield = sequence.Contains("YY");
bool adaptation = sequence.Contains("BG") || sequence.Contains("GB");
int time = Math.Max(1, 60 - 4 * purple + 3 * yellow + 2 * blue + (highYield ? 3 : 0));
int harvest = Math.Max(1, 4 + yellow - purple / 2 + (highYield ? 1 : 0));
int water = Math.Max(1, 6 + yellow - blue - (adaptation ? 1 : 0));

Genome editing test

C#

NUnit checks that changing one gene does not mutate the original sequence.

Assets/_Project/Tests/EditMode/GeneticsTests.csSelected source excerpt
var original = new Genome("PYBGPYBG");
Genome edited = original.Replace(2, 'Y');
Assert.That(original.Sequence, Is.EqualTo("PYBGPYBG"));
Assert.That(edited.Sequence, Is.EqualTo("PYYGPYBG"));

These excerpts are from the existing Unity/C# codebase. The immutable edit returns a new genome, keeping the source instance unchanged. The calculation example derives traits from the validated sequence, while the tests illustrate how rules can be checked independently of runtime rendering. A code excerpt alone does not establish that an APK or desktop release is available.

Code samples are excerpts or documented illustrations; surrounding project files, configuration and dependencies may be required to compile or run them.

04 · COLLABORATION

Team and source provenance

This is a team project hosted in a collaborator-owned repository. The connected repository’s commit history identifies the account below.

05 · RELEASE

Development status

The Unity project has a real codebase and edit-mode tests. No public APK, desktop build or interactive browser deployment has been supplied for this portfolio.

← Personal Projects