Hello Everyone!I just wanted to send out a quick update on v0.2.1 and the introduction of multiplayer, as well as touch on the final exciting core tech improvement that will be included in this update.
Before I get into this, I just wanted to say a quick thank you to everyone who has been testing out the 0.2 build on experimental. Your feedback and been invaluable to me, and has helped to quickly improve the overall quality and stability of the 0.2 branch for when it goes live later this month.
[h2]Multiplayer Support[/h2]
[h3]Experimental Release Date (v0.2.1)[/h3]
As many of you know, I was originally estimating the release of multiplayer to be on May 3rd, but due to a few missing pieces of networking architecture a few days prior to that date, I decided to delay it a week in order to allocate enough time to finish it off and ensure the build was stable and ready for testing.
However, during this week I went down a rabbit hole of component-based architecture, which somehow stemmed from a networking related issue that I was trying to solve. One thing led to another, and now the entire component hierarchy of the game has been completely changed - but for good reason.
I'll touch on specifically what this is below, but for those who just want to know when they'll get to play multiplayer, I am confident I'll be able to have it out into your hands on
May 17th.
Update (May 21st): We ran a very successful test of the client state syncing system and backend connection handling for game sessions, with a lobby of over 10 people all on the same session without any sort of network lag. However, this build had other issues with it that stemmed from the component refactor that I go into detail about below, and so was recently disabled. A v0.2.1b build is being put together for experimental deployment this week and will be far, far more stable!
[h2]Component Refactor[/h2]
[h3]The Biggest Tech Improvement Yet[/h3]
The component refactor is the culmination of the last year and half of work. It builds on top of all the amazing technological improvements I've been making over the past few months, and was the final piece of the puzzle in regards to paying off Vectorio's "tech debt" (requirements to support all future content)
I cannot put into a single message how
immensely powerful and significant this change is, but I'll explain below what is and why it's so important to the overall vision of Vectorio.
[h3]What is the Component Refactor?[/h3]
The component refactor is a
massive hierarchy-based change to how data segments are defined and implemented into their component counterparts. Prior to this, components were defined in a
"ladder-based" hierarchy, where similar data types & components would inherit all the previous attributes and methods from their parent. This worked well in the smaller scope of Vectorio, as many components needed to access or override similar logic to other components, so simply having them inherit / extend that logic was an easy and quick approach for setting up new entities.
As an example, let's say we have a
claimer-type building. Prior to this change, here is out the inheritance structure would've worked (note this is VERY much an over-simplification)...
In this picture, you can see that the claimer inherits all of the methods & attributes from the building component, and the building component inherits all of the methods & attributes from the base entity.
This worked great and was an easy way to quickly get access to certain values or methods that a particular component would need, but doing it this way also locked the system out from being able to define entities that had multiple component functions to them. For an example, here is the drone port...
If we
(theoretically) wanted to create a claimer that also housed some sort of drone in it, we couldn't, or at least not in a way where we could reuse the previous components. This made creating new buildings that utilized pre-existing logic impossible, making it hard to build and expand on.
However, this has now changed with the component refactor. In this new component architecture, components are now defined as individual objects that inherit from a generic component interface, and are stored on an entity through the usage of a polymorphic data list. This means components no longer have a pre-defined structure to them, and are able to operate and execute logic independently of one another while still being able to communicate via their shared base entity. Here's an example...
While the above image may look confusing, essentially what you're looking at is a singular entity with a list of different components. This means the
"Reclaimer" is no longer specifically built from a
"ClaimerData" object, but instead a list of components that make up the Reclaimers logic (in this case, a Building component and Claimer component). While this doesn't change how the Reclaimer operates, it now separates the claiming logic into it's own component
which any building can now use! [h3]Why is this so significant?[/h3]
Obviously component-based architecture is nothing new, and it's one Unity's strong suits in regards to what utilities they offer, but this component system specifically builds on top of all the other amazing core tech that has been designed from the ground up to support the expanded vision of Vectorio.
What I mean by this, is that the components
directly interface with all of the systems that have been developed and iterated on over the past months. This means components can interface with the Entity Manager to receive update ticks, access and utilize the entity model system, interact and obtain info directly from the tile-grid, manage or edit sounds through the audio system, subscribe to events based on certain state changes, request and sync received network state info, automatically handle entity pooling without any boilerplate code, and so, so much more.
This is a
highly customized system that works in the scope of Vectorio, and provides components with all the utilities and data they need to function in an efficient and easy-to-access manner. On top of this, components communicate with other local components via the
e-component system (highly custom interface for Vectorio components), which automatically handles conflicts or missing references without needing any additional checks. It's a very modular system that finally removes the barriers to some
really exciting new content that people have been asking for for a long time.
[h3]When will this be available[/h3]
In v0.2.1 alongside multiplayer! Well this isn't gonna necessarily change any of the pre-existing content, it should give a good idea of where we're headed and why this system was needed. It's the final leap towards a truly modular entity system; paving the road for future content and eventually, mods!
In the meantime, if you have any questions or concerns about this, please feel free to let me know! I know this was a lot of technical talk, but I think it's important to illustrate the significance of this system and why so much time has been spent working towards achieving it.
So thank you, truly, for being patient during this time and allowing me to do this properly. I know early access has been slow so far, but you will see all this work come to fruition in the very near future :)
Thanks for reading,~ Ben