Hi all!

In this update we took a big step towards stability and validity of what we call Layouts. They are data structures that hold information of what Zooids and where they are grown. You might have seen us call them Blueprints too - coders in our team love playing Factorio and that's where from the term initially came. Once we added Aquarium and Layout sharing we wanted to go towards something a bit less technical and we came up with the term "Layout".

When we first coded layouts we wanted to have an easy way to store Sipho templates which could be later used for defining enemies. We would take a snapshot of current player Sipho Zooid positions and save them to a file. If we did that carefully, no position deformations would be stored. We could also later retouch those layouts by hand if we wanted to have Zooids in unusual positions or fix slight offsets that were captured. This wasn't ideal, but it worked for that time being.

Later on, we had to add saving system and save your being-played Layout to not lose it. This was important because one of the cornerstone aspects of this game is player creativity and our task to foster it. It feels very punishing to spend several minutes in Growth mode and then later find part of your Sipho cut-off and destroyed never to recover. That's why we implemented automatic Zooid regrowing.

Then Aquarium came and we allowed manually saving your Layouts. Even though Layout sharing is possible right now through text strings, we didn't pay much attention to validity of saved Layouts as they would mainly be used "for your own purposes" and if they were clean enough for you, we were happy too. Layouts could still be deformed due to physics and saved Zooid neighbours didn't matter much as we re-collected them when growing back from Layout. We did, however, try to fully undeform Sipho when entering Growth mode to preserve somewhat correct Zooid positions when re-capturing Layout. Potentially we might not even need to undeform in the future if we fully transition to Layout-based Growth.

With introduction of Buffer Zooids like Greaser and others importance of connectivity to neighbours was highly escalated. Wanting to buff certain Zooids with Buffer Zooids and seeing them regrow differently was not what we wanted to have as experience - growth should be deterministic and have the same results every time. That didn't come without fun little exploits where it would be possible to attach up to 6 Buffers to the same Zooid and cause some real ruckus.

This update finally addresses major inconsistencies in Layout creation:

• Zooid removal by ungrowing does not re-capture all existing Zooid positions, but rather removes ungrown Zooids directly from Layout
• Growing a new Zooid while there are dead Zooid ghosts no longer re-captures whole Layout - dead Zooid ghosts are removed in the same way as ungrown Zooids
• Repositioning Zooids no longer re-captures whole Layout - repositioned Zooids are removed and re-added cleanly. However we don't re-use "clean" repositioned Zooid data after they are re-added - we re-capture moved Zooid positions. We will fix that in later updates if it deems necessary.
• Grown Zooids have their neighbour Zooids set according to what has been store in Layout - neighbours are no longer re-generated when re-growing and are always kept the same. Previously we would just discard neighbour data saved in Layouts.
• Head Zooids are no longer slightly larger than structure Zooids - we had to have slight margins for growing Zooids initially when Growth code wasn't as mature as it is now

All of your existing Layouts will be upgraded to re-gather neighbours according to saved Zooid position and rotation. Invalid Zooids will remain in Layouts but will be ungrowable - they will appear as Zooid ghosts and will help to fix invalid Layouts.
Now that Layouts are almost independent of your Sipho deformations and can be fully trusted to be valid we will be hosting Layout creation contests to populate upcoming depths.


This huge undertaking was made easier with making use of testing discipline. I have personally noticed that some things require quite a lot of mental power to get started worked on each day - math heavy code, complex code hierarchies, data manipulation. After spending several evenings just to get started on modifying Layout code I decided to write some basic tests to have confidence in different parts of code. With that confidence it was then easier to work on other parts which seemed to be incorrect or harder to test. Now each time I notice that something will require some time to work out how it works or if I catch myself wiring debug messages just to test I consider writing a test instead. That is why you might notice terms "test" in future changelogs. We had tests before, but just now I encountered their real usefulness for existing code. Check'em:
Version 0.6.4

• Add ThreatsLayerMask which is used to determine threats that can be pushed away
• Kill Windows 64 bit standalone when quitting to work around freeze on quit
• Unpause game when selecting Play Again after beating last boss
• Increase epsilon of layout growth point generation
• Adapt all breed zooids when unlocking a breed
• Track kill point deficit and consume food if there is deficit
• Fix deadlock when diving while spawners have chunks to update
• Stop spawners from spawning new chunks after level transition has been initiated
• Reset rotation bias of Zooid button so it's not inherited by other zooids
• Do not recalculate zooid positions when growing from Layout
• Mark Layout statistics dirty when removing zooids
• Make Sipho head size match structure size
• Upgrade layouts that have become invalid after Layout upgrade
• Upgrade built-in layouts
• Only add lower neighbor indexes to layout of grown zooids to avoid duplication
• Add several built-in layouts
• Tests for Layout importer
• Use layout importer to load layouts for Layout Database
• Move Layout version definition to Layout class
• Remove ReadOnly flag from Layouts
• Handle non-existing zooids when upgrading Layouts
• Find upgraded layout zooid neighbors anew
• Save Layouts in pretty format
• Add GetAllBlueprints to growth utils and write tests for it
• Add some upgrader tests
• Add version to Layouts and upgrade accordingly
• Upgrade Layout when importing from string
• Add Layout upgrader tests
• Ensure saved layout zooids are not referencing themselves as their neighbours
• Fix head growth position on layout change
• When copying layout, copy entry neighbors too - fixes layouts not being fully copied and causing corruption of unrelated layouts
• Clear Sipho when setting layout and other fixes
• Refactor Growth layout setting to require calling explicit method
• Various debug things
• Do not recreate Sipho layout when ungrowing or moving zooids
• Add more layout tests
• Start working on selecting a random environment for the next levels
• Do a complete spin180 on the level loading logic and keep most of it inside GameSceneManager and use the Initialize methods to properly setup the area selectors
• Remove the no longer used initial area from IAreaSelector
• Tweak the loading order of campaign scenes - campaign logic promts the loading of the first area
• Add Empty Layout Editor tests
• CampaignLinearAreaSelector now checks with CampaignLogic on whether we're running the tutorial and chooses the next level according to that
• Move Level logic to CampaignLogic from GameStateManager and tweak how the next level is chosen with the linear area selector