Updates Genome Expansion project Weekly Updates


New Member
Hello everyone! This thread serves as an area to post weekly updates of my project with status reports of tasks done as well as expected tasks for the following week. A final blog summary of the entire project will be posted on Medium at https://medium.com/@vedant.294. This forum should contain enough information for people interested in the project but not actively involved with it to understand the status and developments as time passes. Most of the information regarding the tasks lined up is available in the proposal and the Trello board as linked below.

Basic Information :
Project Summary :
My goal for GSoC 2020 is to create a solid foundation with which future modules can implement genomes in an easy manner. Currently, the Genomes module exists in isolation with implementations mostly in the form of unmerged PRs or unused modules. A major focus of this project is to integrate Genomes with SimpleFarming and have it in a usable state at the end of this project. Since this a content-based project, I am also looking to integrate Genomes with other modules which are very close to the player and core elements of the game such as Health, Cooking and Thirst. Another point of work is integrating Genetic Variations in the plants with Biomes and spawning of the different plants in different Biomes. More details on the project can be found in the links above.


New Member
Progress so far:
After studying the subject of genetics and the current implementations of genetics in Terasology, namely Genomes and SoundyGenetics the following conclusions were drawn regarding genetics in Terasology :
  • Rather than merging SoundyGenetics and Genomes as suggested in the proposal, Different implementations of breeding algorithms will be added to Genomes. Traits will be classified as either Continuous or Discrete and corresponding breeding algorithms will be applied as fit.
  • Breeding algorithms are currently registered per-entity in the Genomes module, this should be changed to a per-trait registering system as the breeding algorithm is different for continuous and discrete traits.
  • Discrete traits will breed according to a simple Punnet Square distribution. The exact methodology for breeding continuous traits is yet to be decided.
  • Tinting of items can be done using the implementations in SubstanceMatters. It was done successfully using SubstanceMatters
  • Unsure if tinting of BlockTiles is possible via SubstanceMatters (most probably no). Alternate method should be adopted to tint blocks/parts of blocks. There was some talk of tinting in a PR involving LWJGL3 by @Darkweird, but for the time being, tinting blocks can be ignored/done to the entire block for testing purposes
Details of Meeting #1 - Community Bonding Period (24/05/20)
  • Monoploid and Diploid breeding algorithms need to be studied before changing/adding anything to avoid rewriting any code. Can consult soundwave and casals for this.
  • Might not be a problem to use substance matters right now for tinting items, but can make a new module and remove tinting from substance matters and have substance matters depend on it (in the future)
  • MTE will be used mostly to test new genetics. Can also do standard unit testing for things like the normal function values and stuff, but for events etc, we can use MTE which makes a headless server. Inventory tests should be there by June 7 ish so can refer to that. (discuss with skaldarnar and jellysnake as well)
  • Work with current seed mixer to add breeding (A+A-->A is not possible at the moment. It should be added)
  • An override in genomes which changes UI of seed breeder can be added. This would help the optional dependency of SimpleFarming on Genomes.
  • GenomesAuthoritySystem will go in SimpleFarming, not Genomes. It won't do anything if genomes is not enabled.
  • Need to work on continuous breeding ago. the normal dist stuff will get messed up when parents are not close to avg values. [stochastic simulation or distribution approximation]. Closer to the end, Poisson distribution is better so maybe a combo of two distributions can be used. Also maybe a normal dist with 80% to have in between the parents and 20% outside to add more variation. Maybe normal distribution can be used for now and playtest and then change later based on the observations.


New Member
Week #1 (Coding Period)

So the coding period for GSoC 2020 has begun and week 1 has passed by speedily. This post will contain a progress report of my work during the first week of this coding period and will contain a follow up to add meeting notes for the first meeting during the coding period.

Progress Update:
My work for the first two weeks primarily involves modifying the Genomes module and introducing certain features that allow it to work better with the proposed implementations in the future. Since no real implementation of Genomes exists currently, a test driven approach was followed where a set of tests was written for Genomes, one which worked in the state of Genomes before any modification, and more tests which would work once the work on Genomes was completed. When the first tests are outdated and the second set of tests is working, the work on Genomes is almost complete. The things I worked on this week are as follows :
  • Changed the breeding algorithm registered per organism type everywhere to act as a default breeding algorithm for that type.
  • Added ability to register a specific breeding algorithm per trait to account for different types of traits (continuous and discrete).
  • Wrote multiple tests for the initial Genomes system and for the required genomes system without breeding
  • The first test is based on an existing PR on SimpleFarming which tried to integrate SimpleFarming with Genomes
  • The SimpleGenomeManager is a system that handles all the breeding related events. Here, breeding was done by taking two Strings containing the genes of parent organisms (the genes of an organism are stored as Strings with values appended to it for new traits) and based on the breeding algorithm chosen for the entire organism type, random values were picked from each parent for the Genes. This had to be changed to each gene using its own breeding algorithm to get a proper set of offspring genes following the same trait type (discrete or continuous) as the parents. This was one of the major focuses of the week.
  • A new breeding algorithm, the Discrete breeding algorithm was added to breed discrete traits more effectively and correctly.
  • Testing of the discrete breeding algorithm and the multiple trait breeding was done.
  • Currently working on a Continuous breeding algorithm for continuous traits after which Unit testing of the entire module can be performed.

    PRs made this week :
Meeting Notes: (Coding period #1 07/06/2020)
Topics discussed :

  • Unit tests
  • Swapping tasks for weeks mentioned in proposal
  • Tinting method
  • Trait randomizing at spawn
  • Trello board
  • Genome check command
Notes :
  • Push the discrete breeding algorithm test, no matter how small the test is, it serves as a way of checking if the code is broken in the future.
  • Changes in the schedule in terms of swapping the weeks is fine, the tasks of next week will be more in relation to SimpleFarming and EdibleFlora restructure along with some Genome integration aspects.
  • GenomeAuthoritySystem work will be done this week as well
  • For now the tinting of items can be done via SubstanceMatters, however since there is no real connection between the two modules, at some point it would make sense to remove the tinting mechanism from SubstanceMatters and have SubstanceMatters as well as SimpleFarming depend on that instead.
  • The randomizing of values at spawn can be done via the BushRasterizer code and the SeedBasedGenomeMap. More research needs to be done on the exact structure of this code.
  • Use the progress column of the trello board to put cards of active tasks as well as PRs that are currently open and need review/merging. This would allow other mentors to get an idea of what I am working on
  • The HeldGenomeCheck command will be created which uses the HandHeld component and returns the Genes from the GenomeComponent of the held item.
Last edited:


New Member
Week #2 (Coding Period)

Week 2 of my GSoC project was primarily focused on SimpleFarming and EdibleFlora and adding Genomes to work with these 2 modules. Multiple events were defined to work with the two modules as well as the GenomeAuthoritySystem to handle most of the Genome events. A point to note here is that Genomes is intended to be an optional dependency of EdibleFlora and not a compulsory one.

Progress Update:
The first few days of the week were spent on adding the Continuous Breeding Algorithm to Genomes along with unit tests for this and units tests for multiple traits together. Good amount of time this week was also spent on planning and thinking about the method of adding Genetics in the bushes and seeds, how/when they should be randomized and how the traits are to be passed from one generation to the next. This has made the work for the coming week more straightforward(hopefully) and well planned out. Following are the tasks I accomplished this week :
  • Added a Continuous breeding algorithm to Genomes to work with Continuous traits like rate of growth of bushes etc. It relies on mutation to produce values outside of the boundaries of the parents genes.
  • https://github.com/Terasology/Genome/pull/10 was merged, after which certain issues were identified. Therefore https://github.com/Terasology/Genome/pull/12 was created to fix these issues. Final changes on this PR are pending and will be done in a day or so.
  • Added events to EdibleFlora like onSpawn which is fired when bushes are spawned in the world. The handler for these events is present in the GenomeAuthoritySystem
  • Added Genomes as an optional dependency to EdibleFlora
  • Created the GenomeAuthoritySystem to handle Genetics related tasks in EdibleFlora and SimpleFarming
  • Added the capability for GenomeComponent to be added and passed from Bushes to seed and seeds to bushes and so on when they are planted/harvested.
  • Added the heldGenomeCheck in game console command which uses the heldItemComponent of the player and returns the GenomeComponent if it exists

    PRs made this week :
Meeting Notes: (Coding period Week #2 14/06/2020)
Topics discussed :

  • Best time to add GenomeComponent to bushes
  • Randomizing the Genes
  • Registering traits of different plants
  • Prioritizing tasks
  • EntityRef in events
  • Event chaining
  • Components and Events
Notes :
  • BushRasterizer works at worldGen and architecture wise this would probably be the best place to add it, but there are some possible issues which may cause a timeout of world generation which need looking into
  • Randomizing of traits should be done at spawn using Seed based random values
  • Register plants when they are discovered to reduce code duplication
  • Good to prioritize tasks and keep some for possible additions if time permits during the week
  • Tinting will be a good visual indicator for the player if its linked to filling
  • Events called on particular entities is based on intuition and design thoughts for the event. No hard and fast rule about this
  • Event handlers are chained. Default behavior of event chaining is unsure
  • For both ways, components in signature or in the annotation, the entity MUST have the components for that handler to be triggered.


New Member
Week #3 (Coding Period)

Week 3 was primarily focused with integrating Genomes with SimpleFarming and EdibleFlora. The creation of the GenomeAuthoritySystem was a major achievement this week and a few roadblocks along the way made this a hard task

Progress Update:
The entire week was spent creating events for SimpleFarming to be handled by the GenomeAuthoritySystem in EdibleFlora so that Genomes sits at the EdibleFlora level as an optional dependency. The GenomeAuthoritySystem was also developed and this had multiple challenges that had to be overcome during the week. Following are the tasks I accomplished this week :
  • Added 3 new Events to SimpleFarming to be handled by the GenomeAuthoritySystem
  • Created the GenomeAuthoritySystem in EdibleFlora to handle these Genome related events and transfer the GenomeComponent from bush->seed->bush and so on
  • Major debugging and fixing was required for this as multiple problems arose. Problems listed below.
  • Did some work with Tinting to finalize the method of tinting to be used for items

    PRs made this week : (Both draft PRs, will be ready for review once certain things are completed in the coming week)
  • https://github.com/Terasology/EdibleFlora/pull/5
  • https://github.com/Terasology/SimpleFarming/pull/93
Problems Faced:
  • First, It was decided that the GenomeComponent would be assigned to the bushes on spawn in the BushRasterizer, however the GenomeComponent did not stay on the block after it was added through an event handler. The reason for this was discovered much later to be a problem with the RetainComponent not containing the GenomeComponent
  • Then the multiple events in the SimpleFarming module had to have proper transfer of GenomeComponent from seed->bush when the seed is planted and from bush->seed on harvested. Due to the number of different ways this is handled, it created problems that required lot of debugging
  • The GenomeComponent of a seed when planted, was not being transferred correctly to the bush. This turned out to be a major problem and multiple days were spent debugging this. Finally the cause has been determined as the RetainComponents list in the EntityAwareWorldProvider not containing the GenomeComponent. Thus when a half bush grows to a full bush, it loses all its components including the GenomeComponent. The exact solution to this has not been implemented yet but it will involve adding the GenomeComponent to the RetainComponent list in the world provider.
Tasks remaining before merging:
  • Write modifications for non sustainable bushes to inherit GenomeComponent and not throw NPE
  • Fix RetainComponents problem
  • Major Code Cleanup
  • Optional dependency of Genomes must be enforced
  • Add JavaDoc in the new Handlers and events
Last edited:


New Member
Week #4 (Coding Period)

Week 4 was all about finishing up remaining work and clearing the roadblocks that prevented everything from going forward. The work with SimpleFarming and EdibleFlora is almost complete, as most of the implementation work is completed barring some design issues which need to be handled.

Progress Update:
Following are the tasks I accomplished this week :
  • The RetainComponentsComponent was not reflecting its values in the RetainComponentsList in the EntityAwareWorldProvider, but was rather being passed as a null set on every call. This could be due to certain deprecated method calls in SimpleFarming. This was fixed which allowed the Genome work of SimpleFarming and EdibleFlora to function as intended
  • SeedBreeder work has begun, allowing seeds to breed with like seeds and also breed with genetics is an ongoing task
  • Code cleanup for both draft PRs made last week was done to make it ready for review
  • Support for non sustainable bushes was added so it does not throw NPEs when parents are destroyed
  • Javadoc was added to all the new handlers and events so it is clear what each one is intended for
  • All Genome mentions were removed from SimpleFarming and EdibleFlora, except for the GenomeAuthoritySystem in EdibleFlora
  • Both PRs of last week were marked as ready for review, changes based on the design have been suggested and they will be worked on. Many parts of the GenomeAuthoritySystem will now be moved to SimpleFarming

    PRs made this week :
  • https://github.com/MovingBlocks/Terasology/pull/4060
  • https://github.com/Terasology/EdibleFlora/pull/5
  • https://github.com/Terasology/SimpleFarming/pull/93
Work for the upcoming week:
  • Start with the changes suggested in the two genomes related PRs to redesign the interaction between genomes, SimpleFarming and EdibleFlora so the GenomeAuthoritySystem resides in SimpleFarming
  • Move the heldGenomeCheck to Genomes
  • Complete seed breeder work so it can breed like seeds with genetics
  • Start work with the Cooking module and Health module to identify how the cooking module can be used with genetics and the exact structure of the approach
  • The week after this will be mainly focused on Cooking, Health and Tinting
Last edited:


New Member
Week #5 (Coding Period)

Week 5 was based on finishing up changes regarding SimpleFarming, EdibleFlora and Genomes and requested changes on PRs which would result in restructuring of some code.

Progress Update:
Following are the tasks I accomplished this week :
  • All the content of the GenomeAuthoritySystem was moved to SimpleFarming
  • The HeldGenomeCheck command was moved to Genomes
  • Seed Breeder work was started, however problems with a few events made this take longer than expected
  • The EdibleFlora PR was closed as all its contents were moved to SimpleFarming
Work for the upcoming week:
  • Finish Seed Breeder related work so seeds can breed with Genetics
  • Allow breeding of like seeds
  • Start work with Cooking module
  • Modify Hunger so Filling is reflected by the filling gene of the entity


New Member
Week #6 (Coding Period)

Week 6 was mainly focused on the SeedBreeder work and Filling. SeedBreeder work required some changes to Genomes as well because the structure of certain things in the GenomeManagers had to be slightly modified to work as intended, this caused the task to take longer than expected. Filling work has also begun, however after suggestions from mentors and staff members, the following structure was planned for modification of traits via genomes: Have an event defined in the content module itself and fire this event when a trait is used (for example, fire this event when a fruit with a filling component is eaten/activated), handle this event in Genomes itself with a generalized handler therefore allowing for code reuse and no unnecessary modification of the content modules.

Progress Update:
Following are the tasks I accomplished this week :
  • Completed the Breeding Process of the SeedBreeder to allow breeding with traits to work correctly
  • Added an event to BasicCrafting so other modules can now influence the crafting process as needed after the produce is created
  • Added a handler to GenomeAuthoritySystem to take the input genes of both seeds and create a resultant
  • Used the SimpleGenomeManager for doing this
  • Started work on Hunger and Filling to be affected by the Genes of the eaten seed
  • Defined an event which can be generalized and defined in every content module for modification of some trait via Genes

    PRs made this week :
  • https://github.com/Terasology/BasicCrafting/pull/3 (Not ready to merge, few changes are yet to be pushed)
Work for the upcoming week:
  • Finalize the SeedBreeder PR by adding javadoc, code cleanup and few formal changes
  • Complete the work with Filling and the handler in Genomes which will be generalized for all gene affecting traits
  • Work with Cooking module to be done this week or atleast a substantial amount should be ready to merge
  • Completion of all pending PRs which have been reviewed can be done since all the genome work is finalized


New Member
Week #7 (Coding Period)

During week #7 I was mainly focused on two things. One was tying up loose ends on remaining draft PRs/reviewed PRs and the other was the filling component to be reflected by the filling gene of the seed.

Progress Update:
Following are the tasks I accomplished this week :
  • Completed PR #12 for Simple farming which is now ready for re-review/merging
  • Completed SimpleFarming PR #93 which is now ready to merge
  • Started work on the filling component and genome integration.
  • Initially, it was decided to have an event in Genomes which is handled in Hunger via a partial dependency and a similar pattern for all content modules, however the way genomes is structures, it became hard to do so with a generalized handler since Reflection is not permitted outside the engine.
  • Filling work was completed by adding a handler within Hunger itself and a partial dependency on Genomes. PR on this is yet to be made but the work is almost done.

    PRs made this week :
  • https://github.com/Terasology/SimpleFarming/pull/93
  • https://github.com/Terasology/Genome/pull/12
  • BasicCrafting, hunger and 1 more genomes PR for the modifier trait event to be made in a few days.
Work for the upcoming week:
  • Complete the 3 PRs as mentioned above
  • Finish the Cooking module changes as discussed. This just involves a single method check between the found filling value and expected filling value from prefabs of ingredients.
  • Start work on Biome Integrations. This work spans two weeks so it will begin in the latter half of the coming week


New Member
Week #8 (Coding Period)

After the meeting that took place last week, the main task for this week was to create a new type called ModifiableValue, which can be used within Components to store and modify data. ModifiableValue would have 3 modifiers (preModifiers, multipliers, postModifiers) which can be used to accurately compute the current value of the data member without having to modify the base value of the Component. After this class was created, a TypeHandler for it had to be defined so it is serialized and deserialized correctly from the prefab of the items.

Progress Update:
Following are the tasks I accomplished this week :
  • Created the ModifiableValue class successfully as a new type which can be used as the datatype for data members of components.
  • Implemented the ModifiableValue type with the filling value for the FoodComponent within hunger.
  • The filling value was then modified according to the genes of the seed. This was also implemented successfully.
  • A TypeHandler was created for the ModifiableValue class, however there are still issues regarding the serialization and therefore no PRs have been created on the above mentioned tasks. This is still a work in progress.
  • Previously pending PRs have all been completed. A small summary of the remaining PRs follows.

    Status of remaining pull requests:
  • PRs SimpleFarming#93, Genomes#12 are ready for re-review/merging
  • A PR will be made for MovingBlocks/Terasology once the serialization issue is solved
  • A PR will be made for Hunger once the above task is completed(ModifiableValue fix)
  • A PR will be made for Genomes as well once this is done
  • A PR will be made for SimpleFarming once the crafting is sorted out
  • BasicCrafting PR is also a work in progress.
  • All PRs mentioned above are more or less dependent on the serialization work. Almost all are already completed but awaiting ModifiableValue to work before they are merged.
Work for the upcoming week:
  • Fix serialization issue (main focus)
  • Complete work on all PRs mentioned above. Most are already finished but add final touches
  • Gather all the things that are ready for playtesting so it can be included in the next playtest


New Member
Week #9-10 (Coding Period)

This post contains updates of weeks 9 and 10 as well as a short summary of the tasks accomplished thus far and what is remaining before GSoC 2020 ends. These two weeks were primarily concerned with wrapping up all the SimpleFarming related Genome activities which are now almost completed with the exception of breeding due to an unresolved bug. The next stage of the project is to modify the code of WildAnimalsGenome and to integrate Genomes with biomes.

Progress Update:
Following are the tasks I accomplished in these weeks :
  • Serialization of ModifiableValue was fixed and is working as intended now.
  • The filling of FoodComponent was changed from float to ModifiableValue and all the direct filling accesses were updated to use the getValue() method (namely in Hunger and EdibleSubstance)
  • Breeding work was completed so that Breeding occurs with Genes now.
  • New recipes were added to the SeedWorkstation, eg: Apple+Apple-->Apple. These can be used to breed different types of apples to get the desired Genes
  • Issues in Genomes regarding the breeding checks were fixed. Now, only the length and genomeIds are checked rather than comparing the genes.
  • SimpleFarming's GenomeAuthoritySystem was completed and now contains handlers for Breeding and Giving a modified filling value to the harvested seed. (Part of PR#94).
  • Seeds harvested now correctly get the Filling value from their assigned Genes.
  • Handlers were added to make newly added genes reflect in the game easily. This simplifies the process of adding new traits to seeds.
  • Merging and reviewing of some PRs is remaining but they should be wrapped up this week.


New Member
Summary Post :

In this post I would like to give a short Summary on what tasks I had planned to accomplish so far vs what has been accomplished and the status of other tasks. I will also cover what my project aimed to accomplish and how I have gone about reaching those goals.

The project 'Genome Expansion' was aimed to be a content specific project which integrated certain gameplay elements and added a layer of depth to a simple process of breeding and traits. The Genome module already existed in Terasology before I began my project, however it was not in a state that was usable off the bat, nor integrated with any of the more core modules. Likewise, SimpleFarming also existed in Terasology pre-GSoC but it was not in a state to directly work with Genomes or any other additional module for that matter. To get into the specifics of what I changed with each modules, the weekly posts above may serve as a better communicator but I would like to cover the more broad implications of what I have added. Along the way few bugs/gaps were found in the engine as well which were then fixed to allow a smoother process of adding new features to the mentioned modules. My project serves as a base and allows easy addition of traits and other things in the future. Here is a list of the tasks I achieved and what impact they have :

Genomes :
  • Breeding algorithms are now registered per trait. This allows for different kinds of traits to be added to an organism rather than forcing the traits to be of a single type
  • New breeding algorithms were added to allow more flexibility in defining traits for an organism
  • Adding new breeding algorithms to Genomes should be an easier process now since there is a template that can be followed. The tests written for the new breeding algorithms will serve as a good driver for test based development in the future
  • After traits were added to SimpleFarming, adding traits in a similar manner to other organisms will be much easier since there is a process that can be mirrored
  • New systems were added to Genomes to handle optional modification of traits based on what modules are activated. This again serves as a template for adding new handlers in the future, making the process much easier.
Simple Farming :
  • A new system was added to handle Genomes via an optional dependency (GenomeAuthoritySystem)
  • This system adds traits to seeds and handles all gene-related activities of bushes. It assigns a random gene value on the first harvest of a bush and then the same genes persist through all planting/harvesting cycles of that seed.
  • If Genes were to be added to vines or any other organisms, the same procedure as followed here can be followed to make things much easier. For vines the GenomeAuthoritySystem can be used with the addition of just a few lines of code
  • The filling traits of a seed is now affected by the genes of the seed. The procedure for adding this will be documented properly and therefore adding more such traits in the future will be a very easy process since the handlers, events and entire flow has already been taken care of.
  • Seeds can be bred using the SeedWorkstation to get more desirable traits. At the time of writing this post there is a small bug with this which should be fixed in coming days.
EdibleFlora :
  • New recipes have been defined for breeding purposes. A future goal is to move this to another WorkStation.
  • Filling values of seeds in EdibleFlora will now be affected by the Genes. More such traits can be added very easily.
BasicCrafting :
  • Added a new event which is thrown when an item is produced. This event can be handled by other modules which would like to have an impact on the breeding process by modifying the final product in some way.
  • A template which can be followed exists in the GenomeAuthoritySystem as the genes affect the breeding process of seeds
  • Fixed a bug with duplicate items not finding the correct slots.
  • Fixing a bug with the order of the ingredients having an impact on the output.
Cooking :
  • Modified cooking so that any modules having an effect on the ingredients of a recipe will also affect the cooked item.
  • This has been used in Genomes and will work for any such modifiers
Hunger :
  • Changed the filling in FoodComponent to a ModifiableValue type which can be used by any components to create an easily modifiable data member without ever modifying the base value but rather modify current value using 3 different kinds of modifiers
  • This has been used in Hunger and EdibleSubstance and can be mimicked in other modules that wish to use this type for their components
Engine :
  • Fixed a bug with RetainComponentsComponent not affecting the components to be retained in the EntityAwareWorldProvider. This now allows entities to carry forward the values of desired components even if they are changed in state.
  • Fixing this RetainComponentsComponent bug allows any components to be given to bushes and have them persist past each growth stage.
  • Added the ModifiableValue type which can be used effectively with any components which contain data members which may be modified by other modules in different ways
  • Added a TypeHandler for the ModifiableValue type to handle proper deserialization from prefabs and serialization of the type.
Upcoming work :

With around 2 weeks left on the GSoC timeline, here are the tasks I have planned to complete :
  • Add Biome integration with SimpleFarming, this would affect the growthRate of plants in unfavourable biomes
  • Modify WildAnimalsGenome code so it is working properly with the updated Genomes module
  • Readme and Wiki documentation of my modules, additions and templates that should be followed to add new traits etc
Post GSoC :

I don't plan on going anywhere post GSoC and therefore I will keep contributing to Terasology beyond this project. Post GSoC I would like to start on the stretch goals I had planned for this project like thirst integration and juices, as well as contributing to other areas of Terasology :)


New Member
Instructions to test/play content added by me :
  • Genes with seeds: To add genes to seeds harvested by bushes, the following modules are required : CoreSampleGameplay, SimpleFarming, EdibleFlora, Genomes. Find a bush on the ground in the wild and interact with it by pressing e on the bush to harvest the seed. This will add genes to the seed which can be checked via the heldGenomeCheck console command. There is no other way to know about the genetic makeup of the seed.
    Note for testing: As long as the value of the genes are within the vocabulary of the genes present in the GenomeAuthoritySystem, this works fine
  • Filling/trait modification: Since Hunger is a dependency of EdibleFlora, it will be activated by default when the above process is carried out. Consuming a seed that has genes will give you an increased boost to the filling value than if the seed was consumed when genomes was disabled.
    Note for testing: use the setHunger command to set the hunger to an intermediate value like 50, and then consume the seed. Use the showHunger command to see the new hunger value to know how much hunger was restored via the new filling of the seed. Compare this with the first letter of the gene string. The first letter produces values based on the alphabetical order. eg: A-->+0.5 ,B-->+1 etc.
  • Tinting of seeds: Activate all the modules mentioned above, and also activate SubstanceMatters. Since everything runs on optional dependencies, there will be no issues if it is enabled/disabled. Enabling SubstanceMatters will add tints to the seeds when they are harvested, based on their filling values. The tints are divided into 3 categories for different kinds of tints.
    Note for testing: Seeds with filling less than 1.5f will not be tinted. Seeds with 1.5f-2f filling will get a greenish tint, Seeds with 2f-2.5f will get a blue tint and seeds above 2.5f get a gold tint. These values are adjustable and the different sections can be used to group the seeds for other purposes
  • Breeding: Activate all the modules mentioned for adding Filling modification, and also enable BasicCrafting. The seeds can be bred using the SeedWorkstation. Two seeds of differing or similar genes can be bred in the SeedWorkstation to produce an output seed with new genes. This can be used to produce a more desirable genetic makeup. To breed, have two seeds of the same type in your inventory and click the recipe corresponding to the seed and press 'craft'.
    Note for testing: The filling is bred via the Continuous breeding algorithm, therefore values must correspond to values that are possible using this algorithm on the given input genes.
  • Cooking: Activate all the modules required for Filling modification of seeds, as well as the Cooking module. Harvest seeds found in the wild to get enough seeds to cook a recipe that uses seeds, eg: BananaBread requires 2 Bananas, Flour, Chocolate and Sugar. These 2 Bananas can be harvested from a banana bush and will therefore have modified filling values. The cooked banana bread via the CookingWorkstation will be better than regular BananaBread since it will have a higher filling value
    Note for testing: This modified filling value is a direct sum of the modifications in filling values of the ingredient and therefore can be predetermined and compared
  • WildAnimals: Activate WildAnimals as well as WildAnimalsGenome. Deer can be made to breed by interacting with them and pressing the activate mating button for them. The baby deer will be bred with its speed modified based on the speed trait of the parents, bred via a FavorablyWeightedBreedingAlgorithm.
    Note for testing: there is no visual indicator or metric to know the exact outcome of the breeding process other than logging and observation in game.
Last edited: