My automation game Factor Y is finally leaving early access and will soon officially launch.
The planned date for this is the 26th of August. Launches on Steam are usually tied to a sale, so time your purchase accordingly to save some money.
You could wishlist the game now to get notified by Steam once it launches / goes on sale.
Factor Y is already available on Steam as an early access title.
I started working on it in my free time in December 2020, it’s been nearly four years since then.
Game Overview
Factor Y is a 2D automation game in which the player builds a factory to create new buildings and items via recipes of ever increasing complexity and construction cost.
The game’s world consists of a solar system with multiple planets and moons, each spawning different sets of resources and having different stats such as the maximum brightness and length of day. Items can be transported between planets via space ships.
Factor Y also has a unique Module system. With it, the player can plan smaller factories to then create custom buildings blocks from them.
The game plays like an RTS game. There’s no player model, the camera can be moved freely and buildings can generally be placed anywhere without the need to ‘get there’.
Resources are infinite which removes the need of having to ‘move’ the factory.
I spent a lot of time optimizing Factor Y’s simulation. Due to that one can create truly large, multi-planetary factories.
Please take a look at the Steam Page of Factor Y to see the most recent footage of the game plus a detailed list of its features.
Or take a look at Wally1169’s quite recent playthrough on YouTube. (Note that Factor Y was previously named Combine And Conquer)
Below are some screenshots of the current state of Factor Y:
Project Overview
I haven’t used any of the major game engines such as Unity or Unreal Engine and implemented Factor Y ‘from scratch’ in the programming language Rust.
I greatly enjoyed working with Rust and it is still my favorite programming language after all this time :)
Give it a try if you haven’t yet.
2D graphics for icons are .svg files created in Inkscape that I convert into images when building the game.
Buildings and items within the game are 3D modeled within Blender and also converted to images as part of the build pipeline.
Within Blender I defined multiple cameras and animation frames per object that are then used to generate multiple images per building / item.
For the soundtrack I use FL Studio.
For the build system I use a Makefile that mostly invokes Python scripts or Rust’s cargo.
I also use quite a lot of Python to generate Rust code.
I use Docker to build release versions of Factor Y for Linux.
I also use Linux during development, but using a defined Docker image yields builds that can be used by more distributions.
Current statistics of the game’s project:
source files: 429
test files core: 105
test files client: 2
svgs: 116
blender files: 26
commits: 3137
open TODOs: 772
closed TODOs: 2729The most important crates I’ve been using:
Without them, Factor Y wouldn’t have been possible. Thank you very much.
I’d also like to thank the excellent Rust community in general.
Development Progress
Factor Y has been in development since December 2020. I’ve been working on it as a solo developer in my free time.
Please note that Factor Y was initially named Combine And Conquer, you’ll encounter both names here.
Below are some milestones of the development progress. I will mostly mention clearly visible changes to the game that can be shown via screenshots or short video clips.
Due to that I won’t go into detail about solely gameplay related features or performance improvements.
Note that I maintain a very detailed dev log here. It is much more detailed than what I’ll be presenting here. The following is basically a short summary of the dev log.
The dev log mentions nearly every feature and performance optimization and contains quite many code snippets. It is also timestamped.
Text Based
Since I had to implement the rendering myself, Factor Y started out as a console application that renders text to the console and parses text files for the initial state of the factory.
What the simulation of Factor Y initially looked like:
MMMMMMMMMM
MMMMMMMMMM
MMMM MM<<<
MMMMMMMMM^
))))>vMMM^
MMMMMvMMM^
MMMMMUMMMa
MMMMM>>)>>
MMMMMMMMMM
MMMMMMMMMM
------------------------------------------
MMMMMMMMMM
MMMMMMMMMM
MMMM MM<<<
MMMMMMMMM^
)))>)vMMM^
MMMMMvMMM^
MMMMMvMMMa
MMMMM)>>)>
MMMMMMMMMM
MMMMMMMMMMOpenGL Rendering
After that I migrated the rendering pipeline to an OpenGL based approach. For quite a long time Factor Y didn’t have any textures and only used colored boxes.
The first iteration simply drew gray boxes per building:
After that I added text for the individual types of the buildings:
Plus the orientation > v < ^ of buildings and the item they are holding ([IO] Iron Ore):
After the addition of more building types, color support and a basic copy&paste feature, Factor Y looked like this:
Textures
I then implemented rendering of textures and created pixel-‘art’ images for all buildings and items within GIMP.
The content of buildings was now also rendered on top of them:
Planet Rendering
I then moved on to implement basic rendering of a planet plus a test factory on top of it:
Until this point in time factories didn’t interact at all with the planet and were only part of a Blueprint rendered on top of it.
I started adding resource fields that would spawn on the planet and added the Miner that allows for extracting them.
Structures were now also properly positioned on the planet:
Structure Select
It still wasn’t possible to freely choose buildings / structures for placement. They had to be predefined before launching the game or copied from already placed structures.
I therefore added the new Structure Select view that rendered all available buildings and made it possible to place any of them on the planet:
Render Performance
At this point everything generally worked, but the planet’s render performance was very poor when zoomed out far.
I therefore focused on optimizing it. Below a comparison:
Temperature
Next I added logic for temperature which would then affect the tiles used for the planet.
For example depending on the temperature either Water or Ice would spawn at a specific location.
With the addition of new tiles, planets now looked like this:
State Cleanup / Experimental Multiplayer
I then rewrote how state and events worked within Factor Y. To cleanup the code, have more predictable results and potentially support multiplayer in the future.
After also implementing a basic server for Factor Y I had a working multiplayer prototype.
(Note that multiplayer is still not officially part of the game and may never be added. Please consider Factor Y to be a single-player game)
Animations
Factor Y’s rendering still was static at this point in time and there were no animations of arms, belts and the other buildings.
After implementing animations, the result looked like this:
Research Technologies
I then introduced a Research system for unlocking recipes by investing Research Tokens.
To spend them one would have to place them into a Lab. Note the active research in the bottom-left corner of the screen plus the new Lab building.
Planet Inventory
So far all buildings were infinite and could be placed freely on the planet.
Next I introduced an Inventory for planets. One could now only place buildings if they were available in the planet’s inventory. To add them, one had to put them into the Influence building.
Below an image of the Structure Select with the inventory count next to every building:
Modules
Next I finally implemented Modules. The player can use the Planner to make self-contained factories which are then simulated to create new, custom buildings blocks of practically any recipe.
Below are images of both the blueprint and module that has been generated from it:
(Note that this is a trivial example that just moves iron plates around)
Generated modules were now also displayed within the Structure Select. This made it possible to place them:
UI Overlays
Different UIs such as Structure Select were their own views until now. I changed them to be actual overlays on top of the game’s world:
Improved Modules
I then updated the way modules were rendered. It was now possible to see the components they were made of:
Energy
After that I introduced energy. Most structures would now either use it, generate it or store it.
Initially there was no UI for it and I used text to show the current values of the factory:
Hotbar
So far different views and actions were only accessible via key bindings. I added the Hotbar with buttons for most of them:
Energy UI
Next up I added a secondary Hotbar (top) and a UI for the energy values of the factory (bottom left):
Cursor Modes
I then added ‘cursor modes’ which made it possible to attach an action to a cursor (e.g. rotate building) which is then performed on the clicked structure. This made it quite easy to quickly add new actions to the game, the player experience wasn’t that great, though.
I also changed the hotbar’s theme by then:
Text Improvements
Later I spent some time improving the readability of text by introducing a drop shadow. The Energy UI also got improved by adding text showing the current energy values:
Multiple Planets
After that I introduced multiple planets to the game as well as buttons to switch to the next or previous one.
Note that at this point there was no ‘space view’ available in the game.
Spaceports
To actually support interactions between planets I then added the Spaceport structure and spaceships. With them, it was now possible to transfer items between planets.
One had to setup links between Spaceports to then have cargo ships transport items between them.
Planet Overview
While there was still no proper solar system, the Planet Overview made it more easy to switch between planets.
A thumbnail was generated and displayed for each of the planets to make it easy to tell them apart.
Inventory View
Since it’s important to see which items a spaceship carries, I added a new view to inspect the inventory of buildings and ships:
Spaceship View
Since at this point in time there still was no view for the solar system, I added a new view to see in-flight spaceships with their target planet and distance to it:
Release on itch.io
Shortly after adding the Spaceship UI I released Factor Y as prototype title to itch.io .
This happened on the 7th of May 2022, roughly 1.5 years after the start of development.
Space View
Next up I finally implemented the first version of the solar system / Space View. Planets were still blocks at this point in time and there was no proper background for the solar system.
But planets and ships were properly positioned in space now. This way flight paths also became clear:
Inventory Overlay
The Inventory View I mentioned previously required click-interaction and was an entire view, interrupting the gameplay.
Due to that I decided to implement the inventory as an overlay that is being shown near the target on hover:
Round Planets
I then got rid of the rough edges of planets in the space view and made them round.
Note that at this point in time planets were still rectangles when interacting with them directly.
Improved Space View
After that I further improved the Space View: I added a sun and orbits for the planets.
I also worked on having a near-seamless transition between the planet and space view when zooming out.
Note that these were still entirely separate views at this point in time and it was not possible to zoom back into a planet. The player had to manually click a planet to switch to its view.
Colonization
Next I added the colonization feature that allowed players to colonize new planets to then build new factories on them.
I also added the Colonizer Ship for this purpose. Sending it to a new planet would mark the planet as colonized and seed it with an inventory for a starter factory.
Cursor Tooltips
Especially the colonization feature and space ports introduced rather complicated cursor actions with multiple steps.
I therefore decided to add tooltips to the currently active cursor to assist the player:
Sound
One of the reasons I still considered Factor Y a prototype instead of an early access title was the lack of audio.
I implemented support for machine sounds, UI interactions plus ambient noises depending on the currently active view.
Reworked Textures
I did another round of improving the graphics of Factor Y.
One of the goals was to have all buildings shown top-down instead of the previous mixture of side and top-down views:
Info Box
Next I added the Info Box that shows useful information about the currently hovered element:
The ‘Overlay’
To select structures or pick items for recipes the player was still forced to navigate to a separate view.
I therefore added the Overlay which had an Item (for setting recipes) and Structure (for placement) mode and grouped everything in categories.
This way it became much easier to place structures or set recipes.
Improved Modules
I changed the way modules were rendered to clearly show the used recipe. I also added an indicator to make it obvious that they’re currently active or not.
Vector Graphics
Next I reworked all graphical assets to be done via .svg vector graphics. I used Inkscape for this.
This made it possible to easily tweak the detail levels / resolution within the game. It also made it easier to modify existing graphics.
Below a comparison:
Savegames / Ending Prototype Phase
With the addition of savegames Factor Y was now in a playable state and I decided to officially launch it as early access title on itch.io .
Improved Font Rendering
I improved the font render quality and switched to the Roboto Mono font, greatly improving the readability:
Demo
Next I added a demo for Factor Y. It is equal to the full version except for lacking the ability to load games.
This way a player can try the game with all of its features and continue playing that savegame after purchasing the full game.
First YouTube Content
Shortly after the release of the demo, Factor Y (Combine And Conquer back then) was featured on YouTube by CallMeJeff.
Have a look.
Graphical Improvements
I spent more time focusing on graphical improvements. I introduced a color palette and made sure most colors were picked from it.
I also reworked many of the structures’ .svg files and added color support for text.
The way temperature affected planets was also improved, yielding a smoother transition between cold and warm areas:
Steam Early Access
After the graphical improvements I decided to release Factor Y as early access title on Steam.
The launch date was the 27th of December 2022.
Proper Solar Power
Previously solar panels produced power the same way burners did. The actual brightness or day/night cycles weren’t implemented. Solar power had basically no drawbacks.
I introduced Brightness which affected the solar power production and depended on a planet’s distance to the sun and its day/night cycle.
This way solar power was properly balanced and the player was forced to store energy in batteries during the day to then drain them at night.
Moons
Next I introduced moons to the solar system:
On/Off
To easily disable parts of the factory or to save energy I made it possible to turn structures off:
Production Stats
Since it’s very interesting to know the total output and size of a factory, I introduced a new view to show the production stats of individual planets:
Using Blender
I then started using Blender to model the game’s items, buildings and other assets.
Factor Y itself remained a 2D game. I rendered the 3D Blender models to images to then use those within the game.
Below images of the reworked sun and ores:
After having migrated everything to the new Blender pipeline:
Charts
I improved the way production stats are tracked and introduced new charts.
It was now possible to track and display them with historical data of the entire savegame.
They are shown when hovering individual production stats or one of the power / energy widgets:
Item Stacking
Next I implemented the ‘stacking’ feature. It was now possible to create stacks of items to increase the throughput of the factory and also make flights more efficient.
I added new buildings for stacking and unstacking of items:
Module Coloring
In case the player had multiple module definitions with the same recipe and size it was very difficult to tell them apart.
This would happen when a player started optimizing a module creating several versions of it.
I decided to assign random colors to module definitions. This way even if several would have the same recipe, it was still possible to tell them apart easily:
3D Camera for Structures
So far textures for buildings were always generated via a top-down camera (10 degree angle).
Those textures were also used for recipes and when choosing buildings within the UI.
I reworked this in such a way that structures kept their top-down camera when placed but used the 3D one in all other cases:
UI Rework
Next I rewrote the UI’s toolkit to make it much more usable and flexible and re-implemented most of the UI on top of it.
I also changed the general layout of the UI.
Factor Y now also supported ‘folds’ and sliders:
The UI was now also very responsive and changed its size depending on window size:
I also finally managed to implement a ‘configure dialog’.
Instead of for example setting a ‘recipe cursor’ via a dedicated UI, individual structures could now be configured by clicking them to then open their new configure dialog.
Within it I could now add useful actions that apply to that structure. In case of the Assembler one could now directly set its recipe there:
Within the Launch Pad’s configure dialog it was now possible to see existing links.
For each link the player could either jump to the target location by changing the camera, or remove it.
Note that I introduced generated names for structures to make links more clear.
The UI rework also enabled me to easily introduce the Wiki with useful information about the game. Up until then I had to ship Factor Y with an additional .pdf guide.
I also finally added a tutorial to the game. When active, the important UI elements to achieve a task were also highlighted.
Influence Grid
Next I introduced the ‘influence grid’. Previously this area was simply rendered with a flat color.
Now the game’s grid was shown which made it much easier to align structures.
High Quality Planet Thumbnails
Afterwards I reworked the way planets’ thumbnails were generated and rendered. Previously I had to render them with a low resolution when zoomed out far due to performance reasons.
Thanks to the rework they could now be rendered in a very high resolution:
Plugins
Up until this point in time it wasn’t really possible to ‘filter’ items within Factor Y.
I therefore introduced a Plugin system that could extend already placed structures by adding one of the following plugins:
- Filter: Only accept a specific item
- Count: Only accept N items
- Throughput: Only accept N items per time frame
Modifiers / Buffs
Next I introduced ‘modifiers’ to the game. By unlocking certain research technologies the player could now buff the factory on a global scale:
Blender Improvements
I spent some more time on improving the Blender models, adding more detail and reworking or adding new materials:
Tech Tree Rework
Next I greatly simplified the research technology dependencies which allowed me ‘untangle’ the tech tree, yielding a much cleaner layout:
Closing Words
Thank you for checking out Factor Y’s development progress.
Feel free to ping me if you’d like to know more about specific parts of the game. I’m also open to sharing code snippets.
Make sure to give it a try on Steam. There’s a free demo.
Also note the links at the bottom of this website: You can for example join Factor Y’s Discord or subreddit.
Have a nice day :)