Forem: Long Châu

EZ Mother Devlog #5

Long Châu — Wed, 03 Dec 2025 16:03:39 +0000

Sorry for a long delay.

Last month (Nov-2025) I have a flu that require many weeks to recover.
However, the project is never stop growing.

I feel like this is the best productivity month I've ever done.

I do this project alone and now I have a friend who will do with me. A 2D artist. Yes. Now it's a team.

My project now has more promising.

Changelog:

Update drop rate stat config
Update Mother sprite
Enhance the UI stats with arrow for decreasing and increasing.
Overhaul the movement mechanic. Remove joystick movement and replace with point-and-click movement.
Add visual arrow for movement destination.
User now can interact with items by clicking to.
Block action when interacting.
Have interacting time.
Each item has its own interacted time.
Update more interacting items: TV, Toilet, Toilet Sink, Fridge.

Next planning:

Overhaul the UI.
Add VFX.
Create more items.
Have baby wonder-week.
Baby AI.
More challenges.
Interactable item has black outline while selected item has yellow outline.

https://youtube.com/shorts/VqfG5twOUGQ?feature=share

EZ Mother Devlog #4

Long Châu — Sun, 02 Nov 2025 17:20:49 +0000

Changelog:

Added needs calculation. Now needs can be up or down.
Interact with the items.
Add transparent collider border to stop falling down to infinity.

https://youtube.com/shorts/lMppNlnI5kQ?feature=share

EZ Mother Devlog #3

Long Châu — Thu, 16 Oct 2025 15:50:20 +0000

Changelog:

Finish the kitchen and the bathroom.
Added decrease needs function.
Added post processing effect.
Change the lighting and the shadow.

EZ Mother Devlog #2

Long Châu — Tue, 30 Sep 2025 14:56:53 +0000

Finished the basic UI elements.
Added some basic 3D properties.
Make the player runs around. With the UI touch or by using WASD keys.

https://youtube.com/shorts/ePq5plQ1hKg?feature=share

EZMother: Devlog #1

Long Châu — Tue, 16 Sep 2025 14:58:05 +0000

Platform: PC/Mobile.

Engine: Unity.

Idea:

Brings baby caring after giving birth to game. Have "The Sim" 's needs mechanic. Mom has to take care of herself and the baby.
Stick with the "The Wonder-weeks".
The game ends when the baby is 3 years old.

Art: 2.5D. Character is created by Spine. And decorations are 3D objects.

Prototype:
This is my first devlog. What I've done so far:

Create movement control for Player
Rework top UI
Add WASD movement to support PC
Add 3D items
Add some decors

Result:
I can move the player with the touch joystick and WASD keyboard. There is a bedroom with some decor.

Stimulate Needs:
Stress
Energy
Bladder
Hygeine
Hunger
Show them on UI.

Dependency Injection with VContainer.

Long Châu — Mon, 22 Jul 2024 10:26:33 +0000

Github: https://github.com/LongChau/Test_CSV_Baking/tree/main
Reference link: https://vcontainer.hadashikick.jp/getting-started/hello-world
Link Zenjec: Zenject

We will split dependencies into 2 parts:
Project scope dependencies.
Scene scope dependencies.

Project scope dependencies:
Contains many "managers" that we mark them as DontDestroyOnLoad.
Work as "managers"
Can inject anywhere some object needs it.
Is a singleton.

Scene scope dependencies:
Objects in Hierachy that need to reference to others.
Lifetime equals to scene. Destroy scene => destroy this object.
Is not singleton.
Can be multiple objects. Instantiated by prefab.

To create project scope dependencies:
Create-> VContainer -> VContainer Setting

It will look like this. Then assign a prefab ProjectScope which has ProjectScope script inside it.

Project scope prefab:

Code:

using VContainer;
using VContainer.Unity;

namespace Test_CSV
{
    public class GameLifetimeScope : LifetimeScope
    {
        protected override void Configure(IContainerBuilder builder)
        {
            builder.Register<UserData>(Lifetime.Singleton);
            builder.RegisterComponentOnNewGameObject<GameManager>(Lifetime.Singleton, "GameManager").DontDestroyOnLoad();
            // builder.RegisterComponentInHierarchy<ViewController>();
        }
    }
}

Note: VContainer automatically assign this root scriptableobject to preloaded assets for us. But if you have issue about the injection, you should check it as well.

To create scene scope dependencies:
Parented it the project scope.

Code:

using VContainer;
using VContainer.Unity;

namespace Test_CSV
{
    public class SceneLifetimeScope : LifetimeScope
    {
        protected override void Configure(IContainerBuilder builder)
        {
            builder.RegisterComponentInHierarchy<ViewController>();

        }
    }
}

My Animal Mart (Part 2) - The data config problem.

Long Châu — Wed, 12 Jun 2024 09:41:14 +0000

Foreword

My studio has its own data tool that uses CSV files converted into Scriptable Objects. Some teams refuse to use this and create their own solutions, such as using text files, including them with the build, and reading the data at the first loading screen, among other methods. There is no unified solution for data configuration.

The Background Story

After working on many projects using different tools for data configuration, and after my last game, StarWarrior, where I used CSV files, I decided to find a powerful tool that allows game designers and developers to easily interact with, maintain, update, and delete data. I wanted to eliminate the confusion over which solution to use for future projects.

Using CSV files has several drawbacks: no formulas, no comments (unless you create a comment column), no graphs, no charts, and if you use languages with diacritics like my native Vietnamese, you might encounter formatting errors.

Examples of Bad Cases with CSV:

Format Error:
Naming Conventions:
JumpAttack1, JumpAttack2... and if there are more attacks? JumpAttackN? Despite having the same skill name and buff name.
Character Data:
Another Example:

These data issues make it confusing and difficult for game designers and developers to maintain.

The Technique I Used

To address these issues, I decided to replace the CSV tool with a better solution.

Fortunately, I discovered BakingSheet: BakingSheet. Please give it a star; it deserves that.

The way our GD design the excel is easy for reading and help developer understands.

Introducing BakingSheet:

BakingSheet allows you to convert from Excel (yes, real Excel, with formulas, graphs, descriptions, and no formatting errors) to Unity ScriptableObjects.

Here are some examples:

As you can see, it has child ScriptableObjects under the parent, read-only values, and options for automated conversion. These features are what I like.

What I want to change:

Making read-only values can make debugging difficult. Any changes from the game designer must be done in Excel.
It does not support dictionaries.
It's hard to customize the drawing inspector, as it uses UIElements for drawing.

Modifications I Made:

To better suit my team's needs, I modified BakingSheet:

ScriptableObject values are not necessarily marked as read-only. Developers can choose to make them read-only or not.
It supports dictionaries, allowing any dictionary serialization.
I created a custom flow for generating ScriptableObjects instead of using the example auto-generate method. Game designers can update the data they want.
I developed a ScriptableObject hierarchy that can be created, updated, and deleted.

For example:

Example code:

First off, I'm using Odin Inspector to quickly create a custom inspector. But you can use other free tools for that.
Let's begin with the SheetContainer. In here we have all the sheets we want to have.
'Sheet' here means the sheet in Excel or Google Sheet.

For example, this excel has 2 sheets: EmployeeUpgrade and MasterProductConfigSheet.

Here is the SheetContainer.

using Cathei.BakingSheet;
using Cathei.BakingSheet.Unity;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace Test_CSV
{
    public class SheetContainer : SheetContainerBase
    {
        public SheetContainer() : base(UnityLogger.Default) { }

        // property name matches with corresponding sheet name
        // for .xlsx or google sheet, it is name of the sheet tab in the workbook
        // for .csv or .json, it is name of the file

        // add other sheets as you extend your project
        //public CharacterSheet Characters { get; private set; }
        public MasterProductConfigSheet MasterProductConfigSheet { get; private set; }
    }
}

MasterProductConfigSheet

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Cathei.BakingSheet;

namespace Test_CSV
{
    public class MasterProductConfigSheet : Sheet<MasterProductConfigSheet.Row>
    {
        public class Row : SheetRow
        {
            // use name of matching column
            public int SalePrice { get; private set; }
        }
    }
}

ExcelPostprocess

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Cathei.BakingSheet.Unity;
using Cathei.BakingSheet;
using System;
using System.IO;
using Sirenix.OdinInspector;
using System.Threading.Tasks;
using Sirenix.Serialization;
using NonSerializedAttribute = System.NonSerializedAttribute;
using Cathei.BakingSheet.Internal;

#if UNITY_EDITOR
using UnityEditor;
#endif

namespace Test_CSV
{
#if UNITY_EDITOR
    public class ExcelPostprocess : SerializedMonoBehaviour
    {
        [OdinSerialize, NonSerialized]
        public SheetInfo[] sheetInfos;

        public class ExportSheetEditor
        {
            [Sirenix.OdinInspector.FilePath]
            [ShowInInspector]
            public static string exportPrefabPath = "Assets/Config/Excels/ExportSheet.prefab";

            [MenuItem("Test/Export map sheet data. #&w")]
            static async void ExportMapSheetData()
            {
                var exportSheet = AssetDatabase.LoadAssetAtPath<ExcelPostprocess>(exportPrefabPath);

                foreach (var sheetInfo in exportSheet.sheetInfos)
                {
                    foreach (var config in sheetInfo.dataConfigs)
                    {
                        await Export(config, sheetInfo.excelPath);
                    }
                }
            }

            public static async Task Export(IExcelImportable config, string upgradeExcelPath)
            {
                var sheetContainer = new SheetContainer();
                var excelPath = Path.GetDirectoryName(upgradeExcelPath);

                bool hasPath = File.Exists(upgradeExcelPath);

                // create excel converter from path
                var excelConverter = new ExcelSheetConverter(excelPath, TimeZoneInfo.Utc);

                // bake sheets from excel converter
                await sheetContainer.Bake(excelConverter);

                // (optional) verify that data is correct
                sheetContainer.Verify(
#if BAKINGSHEET_ADDRESSABLES
                    new AddressablePathVerifier(),
#endif
                    new ResourcePathVerifier()
                );

                UpdateSO(config, sheetContainer);
            }

            static async void UpdateSO(IExcelImportable excelImportConfig, SheetContainer sheetContainer)
            {
                switch (excelImportConfig)
                {
                    case MasterProductConfig _:
                        {
                            var config = excelImportConfig as MasterProductConfig;
                            foreach (var row in sheetContainer.MasterProductConfigSheet)
                                excelImportConfig.ImportDataFromExcel(row);
                            config.CheckForDeleteConfigInExcel();
                            break;
                        }
                }

                AssetDatabase.SaveAssets();
                AssetDatabase.Refresh();
            }

            [MenuItem("Test/Open persistent path.")]
            static void OpenPersistentPath()
            {
                Application.OpenURL(Application.persistentDataPath);
            }

            [MenuItem("Test/Clear persistent path.")]
            static void ClearPersistentPath()
            {
                System.IO.DirectoryInfo di = new DirectoryInfo(Application.persistentDataPath);

                foreach (FileInfo file in di.GetFiles())
                {
                    file.Delete();
                }
                foreach (DirectoryInfo dir in di.GetDirectories())
                {
                    dir.Delete(true);
                }
            }
        }

        [Serializable]
        public class SheetInfo
        {
            public string excelPath;
            [ListDrawerSettings]
            public List<IExcelImportable> dataConfigs;

            [Button]
            public async void ImportSheetData()
            {
                var exportSheet = AssetDatabase.LoadAssetAtPath<ExcelPostprocess>(ExportSheetEditor.exportPrefabPath);

                foreach (var config in dataConfigs)
                {
                    await ExportSheetEditor.Export(config, excelPath);
                }
            }
        }
#endif
    }
}

using Cathei.BakingSheet;
using Cathei.BakingSheet.Unity;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using Sirenix.OdinInspector;
using Sirenix.Serialization;

#if UNITY_EDITOR
using UnityEditor;
#endif
using UnityEngine;
using Ultility;

namespace Test_CSV
{
    [CreateAssetMenu(fileName = "MasterProductConfig", menuName = "Config/MasterProductConfig")]
    public class MasterProductConfig : SerializedScriptableObject, IExcelImportable
    {
        [Title("Data section:")]


 [ReadOnly]
        public Dictionary<string, MasterProductConfigData> configDict;

        [System.NonSerialized]
        public const string exportedConfigPath = "Assets/Resources/Configs/MasterProductConfig";

        public void ImportDataFromExcel(SheetRow row)
        {
            var data = row as MasterProductConfigSheet.Row;
            var config = new MasterProductConfigData(data.Id, data.SalePrice);
            configDict[data.Id] = config;
        }

        public void CheckForDeleteConfigInExcel()
        {
            var tempConfigDict = new Dictionary<string, MasterProductConfigData>();

            foreach (var row in configDict)
            {
                if (configDict.ContainsKey(row.Key))
                    tempConfigDict.Add(row.Key, row.Value);
            }

            configDict = tempConfigDict;
        }

        [Button("Save as JSON")]
        public void SaveAsJson()
        {
            var content = Sirenix.Serialization.SerializationUtility.SerializeValue(configDict, DataFormat.JSON);
            var path = Path.Combine(exportedConfigPath, $"{name}.json");

            if (!Directory.Exists(exportedConfigPath))
                Directory.CreateDirectory(exportedConfigPath);

            File.WriteAllBytes(path, content);
        }

#if UNITY_EDITOR
        [Button("Load from JSON")]
        public void LoadFromJson()
        {
            var path = Path.Combine(exportedConfigPath, $"{name}.json");

            if (File.Exists(path))
            {
                var content = File.ReadAllBytes(path);
                configDict = Sirenix.Serialization.SerializationUtility.DeserializeValue<Dictionary<string, MasterProductConfigData>>(content, DataFormat.JSON);
            }
        }
#endif
    }
}

What is happening:

We created a SheetContainer, which contains all our sheets.
We created a MasterProductConfigSheet, which defines our Excel data.
We created a MasterProductConfig ScriptableObject to hold the data.
We created an ExcelPostprocess to manage the import/export of data.

This solution, while more complex than using CSV files directly, provides significant benefits:

Real Excel files with full support for formulas, graphs, and formatting.
Robust handling of read-only values and dictionaries.
Custom inspector drawing, allowing game designers to update data easily.

Conclusion

Switching from CSV to BakingSheet has greatly improved our data management. We no longer face formatting issues or naming convention problems, and the custom inspector makes data updates straightforward for our game designers. This approach has streamlined our workflow, and I hope it can do the same for you.

My Animal Mart (Part 1) - The outline shader problem.

Long Châu — Mon, 10 Jun 2024 07:49:07 +0000

Last year, I developed a new simulation game called My Animal Mart. It’s a fantastic game, and I’ve learned a lot from the experience.

Foreword

The reason we decided to create this game was because we needed to generate more revenue. One day, my PO called the team together and said we had to make a new move. After spending a year working on hyper casual games such as Popit Fidget 3D, Kick the Rainbow Friend, and Save the Dog, we decided to venture into the simulation genre.

The Background Story

We took inspiration from My Mini Mart. At first glance, there weren’t any games quite like it, especially with its unique outline shader. Some competitors didn’t use this technique, likely due to performance concerns.

The Technique I Used

At that time, we used Quibli for outline and cartoon shading. Writing an outline shader isn’t particularly difficult; it typically involves two passes:

Pass
{
    Name "ForwardLit"
    Tags
    {
        "LightMode" = "UniversalForwardOnly"
    }

    // ... shader code ...
}

Pass
{
    Name "Outline"
    Tags
    {
        //"LightMode" = "SRPDefaultUnlit"
        "LightMode"="Outline"
    }
    Cull Front

    // ... shader code ...
}

As you can see, it’s a multi-pass shader that Unity cannot batch. For instance, if it renders 10 apples, it will first render each apple individually, then render the outline for each apple, resulting in 20 draw calls.

Here’s the detailed draw call in the frame debugger:

The game had a GPU bottleneck. With the release date approaching, the optimization task was handed to me. Since we were using URP, I knew we could customize the render pipeline. I decided to try using a Rendering Feature. I created one and called it RenderOutlineFeature.

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class RenderOutlineFeature : ScriptableRendererFeature
{
    private RenderOutlinePass renderOutlinePass;
    public Setting featureSetting = new Setting();

    [System.Serializable]
    public class Setting
    {
        public RenderPassEvent renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        renderer.EnqueuePass(renderOutlinePass);
    }

    public override void Create()
    {
        renderOutlinePass = new RenderOutlinePass();
        renderOutlinePass.renderPassEvent = featureSetting.renderPassEvent;
    }

    class RenderOutlinePass : ScriptableRenderPass
    {
        ShaderTagId outlineTag = new ShaderTagId("Outline");
        FilteringSettings filteringSettings = new FilteringSettings(RenderQueueRange.opaque);

        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            DrawingSettings drawingSettings = CreateDrawingSettings(outlineTag, ref renderingData, SortingCriteria.OptimizeStateChanges);
            context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings);
        }
    }
}

We then went to the Forward Renderer, selected Add Renderer Feature, and chose Render Outline Feature.

After applying the Render Outline Feature, we achieved efficient Unity batching.

Total draw calls:

Opaque apple draw calls:

Outline apple draw calls:

Result

I was thrilled to solve this issue. The GPU bottleneck was eliminated.

Side Story

I contacted Quibli's publisher, DustyRoom, to ask if there was any way to optimize the shader.

Unfortunately, Unity does not support multipass batching (as I knew).

I tried using an outline image effect, but it worsened the game’s performance.

After finding the solution, I shared my idea with them.

They agreed with what I had done.

Unity Version: 2021.3.11f1

Link to the game: My Animal Mart