It's been a while. This is due to the usual convergence of several things happening at once, causing a lack of free time. This was further compounded by the purchasing of Subnautica 2, which then proceeded to take up the free time. : )
While I get back to work updating the GUI, I wanted to do a retrospective on the last month of development. It's important to "look back" from time to time to avoid getting stuck in negative thoughts about your progress. It's the easiest way to remind yourself just how far you've come, regardless of how long it may have taken you to get there.
This retrospective starts back in April, with the very first look at the game;
It was simply the completion of the first few tutorials of DevWorm's Farming Game series. The crops would grow, you could pick them with the mouse, and then by moving the player over the collision shapes at the bottom, it would either open the shop or sell everything in your "inventory."
The inventory was just a counter for various resources, nothing more, so the next step I took was to make and add a real, bonafied inventory. The map was also expanded, and a camera was added to follow the player. This update did break some functionality, so the ability to farm and shop had to be restored. This wasn't too much of an issue, however, as farming was originally done entirely with the mouse, and needed to be updated to be "player-based" anyway.
Complicatico was then updated to use a whole new set of graphics, and ResourceNodes were created. ResourceNodes needed to be very flexible, and respond to player interactions. Player interactions were also expanded to fully interact with the ResourceNodes, and the PlayerCharacter was updated to use a full state engine.
Work on ResourceNodes continued for quite a while, until they had full functionality. They could grow, die, and get harvested, with animations for each. Roughly 20 ResourceNodes were set up for trees, rocks, and a carrot crop.
The last Devlog before I grew busy was refining the physical items. Their spawning was improved and, to improve performance, they were given the ability to merge with other items nearby. They could also be sorted in the inventory, and had some visual updates to show how rare they were, and make them appear more dynamic while on the map.
Development will continue soon, and the next update will show the updated GUI and the preparations I've made regarding the inventory that will be needed for the next step; crafting.
Items have officially been fully set up. They now have more animations to make them appear less static, a rarity index that allows for rare items to stand out in an inventory, and will merge with nearby similar items while on the ground. Items can also now be dropped from the inventory while it's open, or from the hotbar when selected. The inventory can also now be sorted by rarity, in addition to by name.
More below the cut.
With items now finished, we can now move onto refactoring the UI. When we switched over to using the Sprout Lands Asset Pack, the UI didn't get updated to use the new GUI sprites. The addition of a new way to sort the inventory also highlights the...ugliness..of the temporary layout.
The GUI will also need an overhaul to prepare for the next major additions to Complicatico. Some are QoL focused, like more sorting options (price, reverse order, ETC) and the ability to "inspect" items (revealing their name, use, and worth (though shops might deem it worth...differently...than what you do)). The others are pretty substantial and fun - like crafting/recycling, and equipping items.
That's it for now. Thank you for reading, I'll see you once there is more to show.
Log:
Added a "rarity" to items. This doesn't necessarily determine how rare they actually are, but does set the correlating colour of their shine when dropped and the item's border in an inventory.
Added a border to inventory/hotbar/shop slots that appears when an item is "rare" or higher. The colour of this border is determined by the item's rarity.
Added a periodic "shine" to items to make them appear less static. The colour of the shine is determined by the item's rarity.
Added an "idle animation" to idle items to make them appear less static.
It is now possible to sort items by their rarity.
The Player can now drop items from their inventory. While the inventory is open, and the player is holding an item, the player can click outside of the inventory to drop the item. Left clicking drops the whole stack, while right clicking drops one at a time. While the inventory is closed, the player can press "Q" to drop the item that is currently selected in their hotbar. This drops one item at a time.
Items now float towards the player if they're close enough.
Items will now merge with the same type of items close by, preventing the map from getting overfilled.
Items on the ground whose value is more than one will display the value.
Added a number to items on the ground. This number only appears if an item's stack is higher than 1.
Credits:
Sprout Lands Asset Pack by Cup Nooble
No AI was, nor will ever be, used in the creation of this game or devlog.
ResourceNodes have been tentatively finished! All of their core features have been set up and each of the currently planned ResourceNodes have been added. The major additions since the last devlog are the ability to harvest ResourceNodes, the ability to use the hoe to remove grass and till dirt, the ability to plant seeds, and the ability to water them.
More below the cut.
To harvest ResourceNodes, you have to click on the "Harvest" button besides the toolbar. To the game, you've equipped a special "hand" item that allows you to harvest harvestable nodes. Many nodes can be harvested; some, however, can be over harvested. As shown in the video, you can pull branches from trees, but eventually it will become barren as you deplete its resources.
Harvesting also allows you to pick fruit, or pull grass. Fruit will regrow when picked, but grass will die. You can use this to pick up small stones, branches, seeds, or other detritus from the map as well. Harvestable ResourceNodes will drop their fruit/harvest when destroyed with tools, too. Harvesting just gives you a way to pick something up without using a tool and, in some cases, without destroying the ResourceNode.
You have to be within a certain distance in order to harvest a node, and the highlight shows that you're able to do so. The outline uses the same shader I added back in Devlog #3 - the
With seeds, the hoe, and the watering can now completed, tools are all now fully functional as well. The hoe can remove grass and till dirt. Tilling tilled dirt will remove the tilled dirt. Seeds can only be planted on tilled dirt. The watering can uses "durability" to track how much water it has. It has to be filled from water tiles, and will eventually run out and need to be refilled again. The last bit of the video shows that the inventory was also updated so that it can track the durability of an item.
Eventually, tools will each have their own durability, but this won't happen until crafting is implemented - and that won't be done until after the GUI has been updated..which won't happen until after I finish the physical item drops.
For one, the player needs to be able to drop items from the inventory. Items are also a little too static. They could use an idle animation, and be pulled in towards the player once the player gets close enough. To make sure the world doesn't get clogged up with dozens of items, it would also be important to make sure they "merge" with others of the same kind nearby.
Additions:
Added the ability to harvest certain ResourceNodes.
To switch to harvesting, a button has been added next to the hotbar. This has to be clicked and cannot be scrolled to.
Harvest only works on ResourceNodes that can be harvested (they have fruit or a harvestable item) and are within a certain distance to the PlayerCharacter.
Harvesting picks fruit first, then harvestables.
Some ResourceNodes will die or become barren if they are fully harvested.
Added ability to use the hoe:
Removes grass tiles.
Adds tilled soil to dirt.
Removes tilled soil.
Added the ability to sow seeds. This can only be done on tilled soil.
Added the ability to water some ResourceNodes.
Certain ResourceNodes need to be watered. If they're not watered before the next "growth" period, they die, dropping their items. If they are watered, then they will grow. Certain ResourceNodes will need to be watered multiple times before they grow again.
Watered ResourceNodes have a darker "shadow" underneath, so you can see if they're watered or not.
Watering depletes the watering can, and it will need to be refilled. You can only refill the watering can from a water tile.
Added ability to hold the mouse button down while performing an action so you don't have to click every time.
Harvest does not do this, to prevent players from accidentally over-harvesting something.
Changes:
Adjusted items spawning on death so that they spawn during the animation, not after.
Added item Y-sorting (wasn't enabled initially.)
The inventory/hotbar/shop have been updated to show an item's durability, should it have one. The durability of an item will move with it when you move the item to another slot.
Seeds now load ResourceNodes from a string path, preventing infinite recursion and lowering load times.
Changed the direction of hotbar scrolling.
Changed hotbar label updating restarting the animation each time the name is changed. Originally, the name would change, but the fadeaway animation would not reset.
Added cursors to show interactive VS normal cursor. The cursor changes when you're harvesting, and the cursor is hovering over a harvestable ResourceNode.
Credits:
2D Pixel outline shader by Mostly Mad Productions
Sprout Lands Asset Pack by Cup Nooble
No AI was, nor will ever be, used in the creation of this game or devlog.
Huge strides for Complicatico this week. ResourceNodes now drop items when destroyed, and play animations on hit/death.
As another excellent example on how providing just a little bit of feedback and feedback variety can really elevate a game, some ResourceNodes will also "shake" when you walk through them:
More under the cut.
To create these animations, I looked at Chris' Tutorial's Resource Gathering RPG and Rapid Vector's Farming Game tutorials. The former showed the use of particle effects to create the death explosions, while the latter showed how to use a shader to make things "shake."
The tree animation was purely my doing, and wound up taking far more time than it should. The animation itself was simple, but required restructuring ResourceNodes. Originally, each sprite was the parent of the main node - including the shadow, the fruit, and the stump. For the main part of the tree to fall, however, that meant they couldn't be children of that node. This wound up breaking the way the sprites stacked, which then wound up breaking how the Y-sorting worked, so much of the time working on this update was spent adjusting the position of each ResourceNode so that it looked right again.
As a personal treat, I added a silhouette to the player that shows whenever they're behind something. It might be better to, in the future, have the foreground object fade away instead (so you can see everything that might be behind it), but sometimes it's just nice to add something easy and cute. I used HexagonNico's shader for this.
ResourceNodes will still need more work before they're finished. Items dropping on chance hasn't yet been coded, though the framework is there. ResourceNodes hold several Arrays of ItemData, with each array serving as the item's chance to drop. Every ResourceNode will use the "AlwaysDrop" Array, for example, but some may also use the "DropsUncommon," or "DropsRare" Arrays. What's left to code is the ResourceNode actually going through each array, as right now it's only programmed for them to go through "AlwaysDrop."
Items, when being spawned into the world, have a fun little procedural animation. They start small and expand to full size, move in a direction, and rise and lower their main sprite to appear as if they're being "launched" from the dead ResourceNode. The speed and length at which this happens is random, though subtle.
The next big additions will be Crops. Technically, crops already exist, but their implementation was before ResourceNodes were created as they are. Crops will need be to changed to being ResourceNodes, which won't be too hard because ResourceNodes already have the ability to grow. ResourceNodes will need to be expanded, however, to include the ability to be watered and the ability to die if not they are not.
To plant crops, we will also need to add the ability to use the hoe animation. This will need to interact with the tilemaps, removing grass, adding tilled dirt, and removing tilled dirt...
...I'll see you then.
ResourceNodes now drop items on death.
Items are "launched" in a random direction at a random speed within a set range.
ResourceNodes play an animation when hit. There are two animations; one for solid objects, like rocks, and one for flexible objects, like trees and plants.
Certain ResourceNodes will shake when walked through.
Added death animations: solid and tree. As the name implies, "tree" is used for trees, while "solid" is used for everything else.
Added a shader that shows the player behind objects.
Changes:
Adjusted ResourceNode positioning and offsets to correct improper y-sorting on certain nodes.
Work on implementing ResourceNodes is coming along nicely. In the last devlog, I spoke about setting up the backend data for ResourceNodes and coding for that data be read and visualised in game. Now, ResourceNodes can be spawned by the map, grow over time, and can be destroyed by the PlayerCharacter. Observe:
The video shows the destruction of a tree, which leaves behind a stump on death. It then demonstrates changing tools in order to mine a rock. Finally, the player returns to the starting area, and time is advanced by the pressing of a DevKey. This shows multiple trees growing, then fruiting. The PlayerCharacter animations have all - save for running - been set up as well. The seed sowing animation was modified from the wateringcan animation, and the pickaxe animation from the hoeing animation.
More below the cut.
ResourceNodes must hold a lot of different data in order to be as flexible as Complicatico needs. Because each one has individual sprites, they also need individual collision shapes and detection areas. The latter are important so that attempting to hit a bush - which can be mostly walked through, save for a small area in the middle - is not frustrating.
They also need to store the ability to leave behind multiple different nodes. Some grow into other ResourceNodes, while others may die and leave behind a stump. Others still, like crops, will eventually wither away. The barren trees are an example of this. Their sprites were modified from the Sprout Lands Asset Pack Complicatico is using.
All of this has been set up and is functional. What remains is their entire purpose; dropping items when the player interacts with/destroys them.
The spawning of physical items isn't too difficult, but ResourceNodes will have to drop multiple different kinds based on what the node is. An apple tree, for example, will need to be able to grow, store, and drop its fruit in addition to the logs and branches it normally drops. Rocks will need to have a chance to drop ore or gemstones - neither of which are planned currently, but they will be eventually, so ResourceNodes will need a way to store items that are guaranteed to drop in addition to items it has a chance to drop.
These chances can't just be stored on the item, either. This was the original plan, but then I realised some ResourceNodes will have different chances of dropping different items. It wouldn't be satisfying if every rock had the same chance of dropping ore. Rarer rocks should drop ores at a higher rate.
The physical items themselves have been set up, and spawning can begin once I configure ResourceNodes handle loot.
Having ResourceNodes drop items is the next goal, along with some visual feedback for being hit/dying.
I'd be loathe to forget to speak on ResourceNode spawning before I wrote the bullet points. A LevelManager uses TileData from the Ground and Wall layers to check if a cell can have a ResourceNode spawn on it. SpawnableCells are then stored in an array, which is then used to randomly select a location for a ResourceNode to spawn on. Before this happens, the LevelManager places an Area2D on the spot and checks to see if a ResourceNode has already been placed there. Even if each ResourceNode's position is tracked, some ResourceNodes may be large enough to take up multiple tiles, so this must be done. If no other node has been detected, then the new one is spawned. If one is detected, another random position is selected and the LevelManager tries again. This is repeated 3 times before it "gives up."
The LevelManager can be set to spawn with a certain # of ResourceNodes immediately on startup, how often it attempts to spawn a new node, and how many nodes it's trying to spawn. If a ResourceNode is destroyed, then the LevelManager will check if the number of active nodes has fallen below the number it wants. If it is, then it will start spawning again.
Devlog:
Added new animations to the player character (not all are yet functional):
Idle
Walk
Run
Hoe
Chop
Pickaxe
Fill (wateringcan)
Water (with wateringcan)
Harvest
Sow (seeds)
Created the ItemData for all items (not all are yet functional):
Coin,
Greens
CookedGreens
BurntGreens
Carrot
CookedCarrot
BurntCarrot
CarrotSeeds
Acorn
Grass
Mushroom
Apple
Berry
Branch
WoodenPole
Bark
StrippedBark
Log
Plank
Slime
Rock
SharpenedRock
StoneBrick
SmoothedRock
Created the ToolData for all tools (not all are yet functional): Axe, Pickaxe, Hoe, and WateringCan
Added ability for ResourceNodes to spawn.
Spawning nodes checks the location (based on tilemap tiles), then checks if the collision shape collides. Tries again three times, then deletes the node and stops if it fails to spawn a node.
Added ability for ResourceNodes to grow into other ResourceNodes.
Added stumps to certain ResourceNodes. When these ResourceNodes "die," they spawn the stump.
Added barren versions of certain ResourceNodes. These will be spawned if the node dies through over harvesting, age, lack of water, ETC.
Added ability to chop/smash trees and rocks with your axe and pickaxe. Depleting their health destroys the node.
Added ResourceNodes:
Adult Berry Bush
Young Berry Bush
Carrot Seeds
Carrot Sprout 1
Carrot Sprout 2
Carrot Plant 1
Carrot Plant 2
Branch
Grass
Large Log
Small Log
Rock
Small Boulder
Medium Boulder
Large Boulder, Acorn
Oak Sprout
Oak Sapling
Young Oak Tree
Adult Oak Tree
Barren Young Tree
Barren Adult tree
Small Tree Stump
Medium Tree Stump
Credits: Sprout Lands Asset Pack by Cup Nooble.
Tools used:
Game: Godot, Aseprite
Devlog: Krita, SimpleScreenRecorder, Obsidian
No AI was, nor will ever be, used in the creation of this game or devlog.
Devlog 5: Refactoring, replacing graphics, and ResourceNodes.
Days 7-8, May 1-2 2026.
Posting this today so I actually remember to do so before losing myself in work.
A lot of what's been happening the past two days has been refactoring. Code and level setup has to be re-adjusted in order to facilitate the next addition; ResourceNodes.
More below the cut. (there are pictures, I promise.)
ResourceNodes are trees, rocks, crops, ETC. Each of these things require the same elements - a sprite, a collision shape, item(s) to drop, and so on - but they also have differences that need to be accounted for. They're different shapes, for example. Trees will have stumps to leave behind, plants and crops will need to grow or fruit, rocks will need to play a different animation and sound when hit than a bush...
This means that ResourceNodes will have to be flexible. While it is possible to simply create "the rock node" and "the tree node," you wind up having to reuse a lot of code and wind up restricting yourself later down the line. What if you wanted a rock node that creates and replenishes ore over time? Well that sounds a lot like fruiting, but it doesn't make sense to code both "the rock node" AND "the tree node" to fruit when they could simply both be same base ResourceNode capable of fruiting...Even if the phrase "fruiting rock" sounds cursed.
Here's an example of bushes fruiting. These bushes can carry up to 3 fruit. I set up a devkey that emits a "grow" signal when pressed, which allows me to test the growth/fruiting of ResourceNodes until a day/night cycle is set up.
This was a very small, but very pleasing touch. ResourceNodes can be set up to include multiple different sprites, allowing for variety.
You'll also notice the art changed again. I switched over to the Sprout Lands Asset Pack by Cup Nooble. I spent a while splitting sprite sheets into all the items, tilemaps, and player animations Complicatico will need in the upcoming month. This including creating some new sprites and animations, but since they're modified from the Sprout Lands pack and the license asks that I do not redistribute the sprites (even when modified), I can't share them here. Once they're set up in game, you'll get to see them in future videos/screencaps.
The map was also greatly expanded in size. The next steps for the ResourceNodes will include spawning them in, and that requires space. The tilemap was also only a couple of layers initially - now each terrain set has its own layer. Water, dirt, grass, and cliffs. Splitting them up into layers will help with setting up different tools and their use cases (EG; watering can needing to fill with water tiles, the hoe needing to be able to remove grass and till dirt, ETC).
Items have also gotten a touchup. Their ItemData has been split into two; items and tools. Most items will not allow the PlayerCharacter to perform an action or deal damage, so that will just be handled by ToolData. ToolData inherits from ItemData, which means the texture, maximum inventory stack, ETC is all still there.
Items are also getting weight and a bouncecount (may be replaced?) because they're going to need to become physical objects soon, as they will be dropped by ResourceNodes. Up until now, items were just added to the inventory, so they didn't need a physical body.
Because of just how much is changing, the game was split into a new version. The very first one is for posterity - it's the version the very first devlog was about. You can imagine how amusing it was to work out that the game is so early in production that it doesn't count as a release, beta, or alpha...Nor is there enough content to count as a prototype...So it must be version 00.00.00.03.
The next steps will include finishing the ResourceNodes (including spawning, interactability, dropping items) and setting up the new player animations with the new ones from the Sprout Lands asset pack.
Devlog:
Split version into Complicatico V00.00.00.03.
Added new sprites from the Sprout Lands asset pack.
Added/modified sprites where needed to fulfill most of the game's needs.
New animations include; Idle, Walk, Run, Hoe, Chop, Swing Pickaxe, Fill Watering Can/Watering Can Empty, Water (with watering can), Pick/Harvest, Sow Seeds
Swing Pickaxe, Pick/Harvest, and Sow Seeds were created by me by modifying sprites already present in the Sprout Lands pack.
Fill Watering Can/Watering Can Empty and Water (with watering can) are the same animation with and without water.
Item sprites were also created/modified from the original sprites; spear, pickaxe, magnifying glass, greens, cooked greens, burned greens, cooked carrot, burned carrot, cup, filled cup, cup with soup, bark, stripped bark, sharpened rock, and slime.
Because the license requests that the sprites, modified or no, are not redistributed, these will have to be shown in game at a future date.
Tilemaps are now split into four layers; Water, dirt, grass, and cliffs.
Tilemaps now include new datatypes; isWater, canGrow.
isWater will allow you to fill your watering can from that tile.
canGrow will allow ResourceNodes (eg; trees) to spawn on this layer.
Added ResourceNodes!
Trees, bushes, crops, rocks, ETC are all a kind of ResourceNode.
It is possible for some ResourceNodes to have multiple textures, allowing for variety.
Some ResourceNodes can grow fruit over time.
Added ToolData, which inherits from ItemData.
ToolData stores player actions, damage, and damagetype.
Setup a devkey that allows for the advancement of time with the press of a button.
Credits:
Sprout Lands Asset Pack by Cup Nooble.
Tools used:
Game: Godot, Aseprite
Devlog: Krita, SimpleScreenRecorder, Obsidian
No AI was, or will ever be used, in the creation of this game or devlog.
The shop is now fully updated, allowing you to both buy and sell items. This brings the game back up to full functionality, though stock numbers and price values still need to be adjusted.
The shop was also adjusted to be more visually consistent with the inventory.
More under the cut. Bullet pointed list at the bottom.
Almost all of this work was backend, so there's not too much extra to show. The shop has its own inventory, just like the player. This means it can be sorted and have items added/removed to it, as well as removed from it. Selling an item to the shop adds it to its inventory the same way buying adds the item to the PlayerCharacter's.
Setting the shop up this way is both easy (since the code for inventories is already set up) and makes future expansion possible. Sorting shops to find items easier, creating multiple shops, saving and loading shops, etc.
It's late, so this post will have to be cut short, but tomorrow will come with some exciting changes and big gameplay expansions.
Additions:
Inventory Sorting
Changed the visuals to include a sort button on top of the inventory. This area can be expanded to include more buttons later.
The sorting function first merges stacks of items, if possible. It then runs a custom sort (a function already present in Godot) using the item's names as the input values. If the two items have the same name, it sorts them by quantity instead.
Hotbar Scrolling Label
When you scroll through the hotbar, a label appears to tell you what the item you're selecting is. It then fades away.
You can now sell things to the shop.
The shop now has "tabs," allowing you to switch between selling and buying.
Re-added a character sprite so the shop stall looks like it has someone running it.
Changes:
Updated the shop to be visually consistent with inventory/hotbar.
Slots can be selected to see the price and name of the item before purchasing 1, 5, 10 or all of the stock - should you have the money for it, and the shop has that much stock.
Shop has its own inventory, much like the player does. This means items can be added in addition to being removed. The future applications are endless!
ItemData now stores a "SellPrice" and a "PurchasePrice," allowing shopkeepers to overcharge for items they bought from you at a heavy discount.
Limited the distance you can "pick" crops. The outline will no longer appear until you are within this distance.
Bug Fixes:
The hotbar now properly selects the first hotbar slot on load
Tools used:
Game: Godot, Aseprite
Devlog: Krita, SimpleScreenRecorder, Obsidian
No AI was, or will ever be used, in the creation of this game or devlog.
Devlog 3: Restoring gameplay functionality, adding player interactions, and updating the inventory/hotbar.
Days 3-5, April 27th-April 29th, 2026.
The past couple of days were dedicated to back-end restructuring and preparation for future additions. Large scripts were split into several smaller ones, code was rewritten and refined, and node tree order was modified for the GUI. The PlayerCharacter now has a node-based StateMachine, courtesy of Rapid Vectors, and a new Area2D that allows them to interact with other collision shapes.
The ability to buy from the shop and plant and harvest crops was restored. Buying and harvesting can now add items to the new inventory, and you can plant seeds from the hotbar.
Behold! Gameplay.
More below the cut. Bullet-pointed list provided at the bottom of the post.
The PlayerCharacter had two important additions. The first is a node-based StateMachine. A "state" can be anything from walking, swinging a sword, dying, ETC. Having a StateMachine allows for the easy managing of each state's personalised code (eg; walking using directional input and moving the PlayerCharacter), transitioning between states, and making it easier to prevent bugs and otherwise keep the PC feeling polished (eg; preventing the PC from moving while dying.)
The second addition was a new Area2D, which can be used by certain states to interact with other parts of the game. This ToolArea2D comes with a function that moves it on a 3x3 grid centered on the PC. It moves based on the mouse's angle to the PlayerCharacter. It also updates the animation direction. If you were to try to plant a seed above the PC, for example, the ToolArea2D will be moved to the topmost part of the grid and the planting seed animation will play in the "upwards" direction. Here's a GIF demonstrating this:
While shop useability has been restored, the next step will involve adding stacks of items to buy. The original code was meant to be more like an incremental game, where you unlock new seeds. Now, planting requires individuate seeds. The shop is also visually inconsistent with the inventory, and you still can't sell anything. These are the next things to be added - along with the ability to sort the inventory with the press of a button.
Log:
Additions:
Added an Area2D to the PlayerCharacter to allow the player to use "tools." This area will be called the ToolArea2D.
When using a tool, the ToolArea2D can be toggled on to detect whether or not the area is colliding with anything. If the proper collision is detected, then the code can continue.
EG; if you're trying to plant seeds, and the detected area is tilled soil, then the seeds can be planted.
This area is moved on click by detecting the mouse's angle to the PlayerCharacter.
The ToolArea2D is restricted to a 3x3 grid around the player.
If the click is close enough to the character, the ToolArea2D is placed on the character. This allows the player to, for example, plant seeds on the tile they're on.
The same method used to move the detection area also changes the direction of the played animation. Complicatico will only use 4-directional animations, so the PlayerCharacter will not always face the precise direction of the ToolArea2D.
Changes:
Inventory/Hotbar:
The inventory and hotbar have been made smaller. They now have 12 and 6 slots respectively.
Code and GUI setup have been set up to allow for the ability to increase their sizes in the future.
The hotbar is now fully connected to the PlayerCharacter, allowing it to "send" the currently selected item's data to the player.
This allows the player to perform actions based on the selected item.
The inventory visuals have been modified to make it clear that the top row of slots are the same as the hotbar.
On opening the inventory, you can see how much money your character currently has.
Items:
ItemData has been expanded to include actions.
Action1 is used by Mouse1.
Action2 is used by Mouse2.
The only current action is "Sow." This is currently stored as a String, and will need to be changed.
Seeds are no longer infinite. A seed is used each time it is successfully planted.
PlayerCharacter:
PlayerCharacter now uses a node-based StateMachine, courtesy of Rapid Vectors.
States include: Idle, Walk, Sow, and Pick.
Each state controls the animation that needs to play, as well as running any specialised code a state might need. For example, walking needs to move the PlayerCharacter, while Sow needs to plant seeds.
PlayerCharacter now has addition animations for sowing seeds and picking plants.
These animations activate special functions (methods).
To sow seeds, the ToolArea2D is moved in the player's mouse direction and turned out to check for collissions. If the collision includes tilled soil, it plants the seed, and removes it from the inventory.
To pick plants, the method checks to see if the player's mouse is hovering over a valid "thing to pick." If it is, it "picks" the plant. If the plant isn't fully grown, it is simply deleted. If it is, the plant's harvest is added to the inventory before deleting itself.
Other:
The camera now starts on player's position, so the game doesn't begin with the camera moving to the player's position.
Changed the shop buttons to use actual buttons after finding "TextureButtons" exist. Do not ask how the "buttons" worked before.
Things that can be "picked" have an outline when you hover over them, indicating that they can be picked. This shader is courtesy of Mostly Mad Productions.
Bugfixes:
The shop is functional again, allowing you to buy items and have them be added to the new inventory.
Fix item(s) disappearing when you close the inventory and there's an item still present in the slot you picked the item(s) up from.
Credits:
SproutLands Asset Pack by Cup Nooble
Rapid Vector's State Machine.
2D Pixel outline shader by Mostly Mad Productions.
Tools used:
Game: Godot, Aseprite
Devlog: Krita, SimpleScreenRecorder, Obsidian
No AI was, or will ever be used, in the creation of this game or devlog.
Today, Complicatico received one of the most important elements of any game; an inventory.
TL;DR: I added an inventory which took most of the day, as inventories are very complicated. This broke key points of yesterday's development, but those will be fixed shortly. I also added new art assets and updated the game to use the new sprites. Finally, I added a camera that follows the player...Though the map is a little small to fully appreciate it.
Specifics below the cut. There is bullet-pointed changelog at the very bottom if you'd like to skip the yapping.
Day one's "inventory" only worked because it was simply a list of numbers linked to a picture along the top of the screen. This works for games that only have a handful of items, but it will not work for Complicatico. The problem is that a genuinely, modular, interactive inventory is incredibly complicated.
The actual data for an inventory is pretty straightforward. You simply need an Array of InventorySlots. InventorySlots hold ItemData and ItemAmount. These two types of data can then be used by the GUI to show the item's picture (which is stored in ItemData), and how many of this item is in that slot (the ItemAmount).
From there, the complication starts to snowball. You need to be able to add items to the inventory. To do this, the item has to cycle through each InventorySlot to find an empty one. Unless, of course, you want items to stack - in which case, it needs to first try to find a stack of the same item before trying to find an empty slot.
That still isn't too difficult, but players typically want to be able to move things around in their inventory. Especially when you have a hotbar, like Complicatico does. This means each slot needs to act like a button and respond to being clicked. The item then needs to be picked up and follow the mouse - and also, be removed from the inventory. Then, the item needs to be put down where the player put it. The code used to add items won't work for this, since that just places the item in the first place possible.
You also don't want to only be able to pick up/put down entire stacks. Players need to be able to split stacks, or only pick up/put down one at a time. This means you need to add both a left click and a right click - and another key to hold down? Not everyone has enough mouse keys to address every way they want to interact with these items.
While the player is moving items around, it's very easy for data to get lost or duplicated. Players will want to be able to merge stacks, too, and if there's a stack limit then some leftover will have to remain either in the player's "hand" or in the inventory.
Then there's swapping stacks - if you can't stack it, you at least want to swap it out for whatever's underneath, right? Well now you have to make sure that both item's data is properly swapped without cloning or entirely losing the other.
There's a reason item-cloning bugs are so common.
This is also unlikely to be the most efficient way to handle the inventory. The code was done entirely without any guidance, and Godot's Dictionaries are now typically used for handling the inventory thanks to recent updates improving Dictionary usability. I'm being stubborn, however, and opting to go for a route I find more readable.
The inventory took almost the entire day's worth of work. Each step required going back and making sure items weren't getting lost/being cloned - if not just breaking the game entirely. I also took a detour and starting working on inventory sorting (this is the greyed out code at the bottom you can see in the image above). The code seemed to work, but with nearly 300 lines of un-edited code above...Inventory sorting should probably weight until after a thorough re-read and refactor.
That isn't all that needs to be rewritten. By removing the previous inventory and adding this one...Most of what was done yesterday no longer works. The crops and shop still work, but because they don't allow you to harvest/buy/sell the new items that this inventory uses, you can't actually do anything with them. This will have to be fixed as well.
Oh, and if you saw post #1, you probably noticed the level looks quite different. Before starting work on the inventory, I looked at DevWorm's more recent ARPG tutorial series. There, he shares another asset pack. I combined this with the previous assets and redid the level's tilemap. He also shared the GUI assets for the inventory he creates, but admittedly I haven't watched any of the ARPG videos yet. Once I fix Complicatico's playability and finish working on the inventory, I plan on following the series to see what he does. I'd like to add combat and dialogue, since the latter especially adds a lot to a game's character and...Well, I shouldn't get too far ahead of myself.
I also added a camera2D to follow the player. The map is currently too small to truly appreciate this, but the code for the camera allows it to auto-bind itself to the size of the level. This means the level size can change and I don't have to touch the camera, because it will always remain within the playable area. Godot has a pretty common issue with the Camera2D that causes pixel art to jitter and tear. I followed a tutorial by Rapid Vectors to help fix this - though, again, there isn't that much space to move around.
If you're able to see that faint blue line, that defines the bottom of the camera. There's probably only a single tile's worth of movement at the moment. The camera is over-baked. At least I no longer have to touch it.
Changelog:
Additions:
Added new sprite assets from Shade's Puny World series.
Added a Camera that follows the player. The map is currently small enough for it encompass almost the entire level, but as the level expands it will become more noticeable.
The camera automatically restricts itself to the map area; so it will automatically expand to fit larger sizes as they're implemented.
The camera uses code by Rapid Vectors to fix Godot's pixel art jitter/tearing issues.
Added a proper inventory.
This inventory is modular, interactive, and includes a whole new kind of ItemData.
It is possible to drag and drop items, picking up/dropping a whole stack with left click, and picking up/dropping one a a time with right click. If you hold shift while left-clicking on a stack of items, you will pick up half of the stack. Shift right-click currently does nothing.
It is also possible to swap stacks of different items, or items that have reached their maximum stack size.
ItemData now allows for the creation of many items without having to change any code. This replaces the old system, which used a pre-programmed list of items to keep track of what the player was holding.
This unfortunately means that the crop harvesting system is currently broken. It's an easy fix - but one that will be tackled later.
Changes:
Split sprite sheets into individual, more easily usable sheets (EG; tilemap spritesheet, player spritesheet, item spritesheet, gui spritesheet, ETC)
Updated the GUI, tilemaps, player, crops, and seedpacks to use the new sprites and spritesheets.
Changed the testing level layout. We are now on TestingLevelV2.
TestingLevel (v1) screencapped and saved for posterity.
Bug Fixes:
Fixed a visual bug relating to buying things from the shop. Originally, when purchasing an item, it wouldn't update the array of purchaseable items unless you exited/reentered the shop. It now reloads on purchase.
Fixed tilled soil not resetting after you harvest a crop from them. Tilled soil originally disabled their ability to detect seedpacks to prevent you from planting a seed while a crop was growing. The code was missing a line resetting this ability.
Tools Used:
Game: Godot, Aseprite
Devlog: Krita
Credits:
Shade's Puny World Series
Josie Makes Stuff's Pixel art Farming assets
DevWorm's ARPG tutorial series
Rapid Vector's "Camera Smoothing and Fix Jittering in Pixel Games"
No AI was, or will ever be used, in the creation of this game or devlog.
During a sleepless night, I was struck with overwhelming motivation to finally do what I have wanted to do for nearly five years: create the game I want to play. At least, one of them. At least, try.
I will spare you the life story and skip to the first day's progress.
Image one shows a raw image of how the game starts. Image two shows the game with collision shapes (the blue areas) on, along with the shop menu. The collision shapes are used to block player movement (such as on the fences and shop stalls) and detect other collision shapes. The shapes on the fields detect when the seedpack is dragged over them, which allows for planting to happen. The two stalls open and close the shop menu, and sell all of the items in the player's inventory respectively.
More below the cut.
I started by following the first four episodes of this tutorial by DevWorm on Youtube. This is an old series of his, and you can certainly tell. Much of the code and node setup leaves a lot to be desired, but it gave me precisely what I needed; a starting point.
This is DevWorm's code on the left, and mine on the right. Both are for the PlayerCharacter, and handle how the player is meant to move and animates the player's sprite based on the movement. You can tell that our approaches are quite different. For one, mine allows for diagonal movement, and splits player movement and player animation into two separate functions. Note that neither of these are the full scripts, and that mine will be changed in the future to use a proper state machine.
Another image of the game, collision shapes off. When you buy a seedpack, a new "resource counter" appears in the top left of the screen to start tracking the new crop. The shop holds each of the possible seeds in the provided asset pack. The shop is coded to allow for more modularability than what DevWorm writes in his video.
This is what the scene tree looks like in game. DevWorm's tutorial hosts nearly everything on the same MainLevel node, but I opted to have a GameManager and a GUIManager load in as globals when the game starts. Often, tutorials are meant for beginners and people participating in Game Jams, so it would be detrimental to follow them exactly, even when there is nothing wrong with their provided code or node setup.
Note that none of this is meant as a critique or "dig" at DevWorm - rather, it comes from the innate desire to explain that my game, internally, looks nothing like what the tutorials provide, and that hopefully this is expressed without needing to show each and every individual line of code.
I only followed the first four tutorials because there is little reason to expand into NPCs, cutscenes, and weather until after a proper foothold on the player, the world, and their ability to interact with it has been established. This will include a proper inventory, as the current one simply tracks the values of pre-programmed items.
Currently, the game allows you to plant crops with a seedpack. Seedpacks can be used infinitely. The crops grow over time, and can be picked by clicking on them. Picking on them too soon deletes the crop; allowing you to plant something else there. Picking a crop once its done growing adds it to your "inventory". Crops are sold automatically by walking to the right (empty) stall, which gives you money. Money can be then used to buy more seedpacks at the left stall, which allow you to plant crops that are worth more money. This could make for an excellent incremental game setup, but it is not what I'm aiming for.
Development will continue with the creation of an actual inventory, and items to fill it.
This is a devblog for Complicatico (working title.) It is intended to help encourage consistent progress on the project. This blog may grow as the game does.
Complicatico is a never-ending project that will serve as an excuse to learn game development, writing, art, animation, and music. This project is only just beginning, and I will be following tutorials during this beginning stage. Complicatico is going to look like a Stardew Valley farming sim for some time, but it is not intended to be. Specifics are under the cut.
Complicatico is a game project being made in the Godot engine. It is not intended to have an end state, though there are goals I would like to reach. Developing a game often overwhelms due to the fact that it isn't just designing and programming a game. You have to learn how to plan projects and motivate yourself, you will need to learn how to do art and animation, how to write and edit stories, music and sound design, ETC. It is a massive undertaking because it is the ultimate multi-media project, and it is irresistible as a concept.
This is a concept that will take many years, and require the learning of new skills; both literal and personal. This is a project I want to do not because I have a "Dream Game Idea," but because the idea of having a hobby that affects me as much as I affect it feels incredibly beautiful. It would be amazing if other people were to be able to play an enjoy what I create, but ultimately this is for me.
The development process is still in its first stage: setting up the basic gameplay. This means setting up the player character and how the player, the world, NPCs, how the player and NPCs interact with the world, ETC. Visuals, audio, story, and raw content are not a part of this stage.
For this stage, I will be following tutorials. They will be linked and properly credited when mentioned, but you may find that Complicatico will not resemble them. I have enough experience with Godot to not need tutorials in order to create a system, but tutorials provide far more than just "how to do X." They give links to art/audio assets, provide inspiration and, most importantly for this project, give it some structure to follow.
The one limiting factor is that tutorials often follow trends, so I will be following them as well. Complicatico is going to look like a Stardew Valley clone for a long while, then start to diverge as the main gameplay systems are completed and I move onto refactoring actually structuring the game in a way that will suite the next steps.
Until then, thank you for reading, and I hope you enjoy the journey.
TTinn, 25th April, 2026.
Firm edit: No AI has, or will ever be used, in the creation of this project or the development of this blog.
