I’ve been using unreal for sometimes and it’s a pretty amazing engine. I found that they have UPROPERTY(meta=(BindWidget)) to binding UI variable declaration in the C++ code and the Widget.

UPROPERTY(meta=(BindWidget))
UTextBlock* TextBlock_PlayerName;

Unreal will bind that variable into the UI component that has the same type and name. And lately, I also see that Godot has its own binding, and they improve it in Godot 3.5. But, I do not find Unity built-in UI binding. I did not check the UI Toolkit yet or any other frameworks. So I decide to make my own binding inspired by Unreal.

Requirement

This UI binding must fulfil these criteria,

• Bind UI declaration in code with the UI component in the scene.
• Warn the User when the binding lost its reference.

Implementation

How to bind?

C# attribute is used for binding the variable, this attribute act as a mark and later the variable with this attribute or mark can be retrieved using reflection.

How to assign the references?

The UI class need to inherit from CanvasUI class, a base class of each UI in this framework. We need to retrieve this class instance to assign the reference to the variable of this class. Using attributes for marking this class is possible, but I want to add basic functionality to the UI, so I need to use class.

public class TestPanelUI : CanvasUI
{
    [BindUI] private Button ChangeTextOne;
    [BindUI] private Button ChangeTextTwo;
    [BindUI] private TMP_Text ChangeTextTarget;
}

How to warn broken reference?

We want to warn the user that the reference may be broken when especially after they modify the scene, and after compiling. They may accidentally rename the GameObject or change the variable name.

We will listen EditorApplication.hierarchyChanged for scene modification and execute the code to validate the binding reference.

And we also use DidReloadScripts attribute, this will be triggered after unity recompiles its assemblies.

[InitializeOnLoad]
public static class UIBindingValidator
{
    static UIBindingValidator()
    {
        EditorApplication.hierarchyChanged += ValidateUIBinding;
    }
    
    [DidReloadScripts]
    public static void ValidateUIBinding()
    {
        // Validation code here
    }
}

Why use reflection?

Normally we bind the reference in the unity editor by drag-dropping the game object into the field. This may be fine in a small scope project but in a bigger project, this may take a longer time. So, we want to do it automatically for a different types of components. We need a reflection to help us find which variable and game object we want and bind them.

Is it possible not to use reflection?

I believe it’s possible but with many limitations. It will require a lot more setup, such as

• Declare using base class.
• Cast the reference.
• Difficult to check using field name.
• Need to wrap the variable if needed.

That’s the limitation I can think of. Reflection also does the same with the check but since we can use and check the type of field in runtime, we can find the right type and the right name for the reference.

Setup

Follow the setup below to use the UI Binding in your games,

• Add the GameCanvasSystem into a GameObject.

• Create the UI class, and inherit it from CanvasUI.

    public class TestPanelUI : CanvasUI
    {
      
    }
  

• Add the field you need, and make sure its name is the same as the one in the scene.

• Add BindUI attribute into the field.

    public class TestPanelUI : CanvasUI
    {
        [BindUI] private Button ChangeTextOne;
        [BindUI] private Button ChangeTextTwo;
        [BindUI] private TMP_Text ChangeTextTarget;
    }
  

• Press play.

You can find the project here.

Thank you for reading 😃 I hope you enjoy it.

Have a nice day.

For long list of item id this is not really a good solution, but for short id this should be fine.

ScriptableObject

ScriptableObject is used for the user interface of this generator because the user most likely wanna have more than one enum generator they can edit. In this ScriptableObject, we need to define directory, namespace, enum name and values.

Generator

There are two ways to generate this enum,

1. Create a template file.
2. Using C# CodeDom.

Using CodeDom the generated code will be automatically indented and there should be no error in the indentation or spacing.

This code generator is also can be used for unit testing, but it’s on another level.

For this simple generator, we just need to create,

• CodeNamespace, represent a namespace declaration.
• CodeTypeDeclaration, this is where we can declare enum, class, interface and struct.
• CodeCompileUnit, a container for the CodeDom program graph or the above variable.

private readonly CodeNamespace _codeNamespace = new();
private readonly CodeTypeDeclaration _codeTypeDeclaration = new();
private CodeCompileUnit _codeCompileUnit = new();

public EnumGenerationSystem()
{
    _codeTypeDeclaration.IsEnum = true;
    _codeNamespace.Types.Add(_codeTypeDeclaration);
    _codeCompileUnit.Namespaces.Add(_codeNamespace);
}

Use CodeMemberField to add the enum values. CodeMemberField is used to declare a field or type.

foreach (var enumValue in Values)
{
    CodeMemberField field = new CodeMemberField(EnumName, enumValue);
    _codeTypeDeclaration.Members.Add(field);
}

And finally, write the code into a C# file.

CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CodeGeneratorOptions options = new CodeGeneratorOptions
{
    BracingStyle = "C"
};

using (StreamWriter sourceWriter = new StreamWriter(filePath))
{
    provider.GenerateCodeFromCompileUnit(_codeCompileUnit, sourceWriter, options);
    AssetDatabase.Refresh();
}

Trigger

For the trigger to generate the enum, we use ContextMenu, not pretty convenient compared to a button, but at least we can use it. Later we can update it to use a button or even a custom editor window, but I stick to ScriptableObject because this is the faster way to get the generator working.

[ContextMenu("Generate")]
public void GenerateEnum()
{
    EnumGenerationSystem enumGenerationSystem = new EnumGenerationSystem
    {
        Namespace = nameSpace,
        EnumName = enumName,
        FileDirectory = Application.dataPath + "/" + filePath,
        Values = values
    };
    
    enumGenerationSystem.GenerateEnum();
}

Result

Below is the generated enum from the ScriptableObject above.

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace NoodleEater.Toolset.EnumGenerator
{
    
    
    public enum ItemTier
    {
        
        Tier1,
        
        Tier2,
        
        Tier3,
        
        Tier4,
        
        Tier5,
    }
}

You can see the source code here

Thank you 😊 I hope you enjoy it.

Sheep

Instead of putting the sheep inside a cage, I decide to let them roam in the field and search for food. This also makes me add weed to the farm, the weed gonna be eaten by sheep, and you need to pull it before planting anything.

Scenario

For making the game have a bit of a story I add a short narrative into the game to guide the player, give the player and also add a quest for the player to finish. The story gonna be a pretty common one, the story is you were fired from your work because of a pandemic and you take a loan to work on a farm to pay your loan and start a new life.

Mail

Mail is used to deliver part of the story and quest to the player.

UI and Fonts

I want to keep everything minimalist and not much UI, so I decide not to make a sell panel but instead use the inventory UI directly to sell the item.

• UI for plant or build.
• Inventory UI.

Next Update

• Finish current features.
• Polishing existing features.

Thank you 😊 I hope you enjoy it.

A few days ago my friend stumbled across a problem because of the usage of GameObject.Find, it can’t find the game object because the game object was renamed. So, I thought we can have something like Unreal Engine redirector to solve this problem.

In Unity, There is FormerlySerializedAsAttribute, which is used to rename a field without losing its serialized value.

Structure

Data

• GameObjects

  This data comes from Unity Engine itself, to retrieve this I use

  Resources.FindObjectsOfTypeAll(typeof(GameObject));
  

• ScriptableObject

  The scriptable object is used to store all the game objects. I create a custom class to hold the required data.

  public class NameConfig
  {
      public int hashCode;
      public string oldName;
      public string newName;
  }
  

  • The hash code is the game object hash code, it uses to check whether a game object name is changed or not.
  • Old name store the current game object name.
  • New name store the new game object name.

System

Since I can not find any event for rename I use EditorApplication.hierarchyChanged, below is the step I do to check rename in the game object.

• Listen to EditorApplication.hierarchyChanged.
• When there is any change in hierarchy,
• Find the data that match the hash code of the current game object.
• If any change then stores the new name otherwise clear it.

I also use a MenuItem to create a menu to register all the game objects manually. It will directly store the data in the ScriptableObject, I use it because working with ScriptableObject is easy and does not require any parsing.

API

I want to override GameObject.Find but it seems I can’t do that, so I create an extension method so it gonna looks more natural,

gameObject.FindByName("game object name");

Conclusion

The GameObject.Find can be solved using redirector, but it is gonna need more improvement in the future. This experiment’s purpose is to be a proof of concept. But it gonna need more effort to make a better and more advanced version of the redirector.

Improvement

• Make sure if the hash code is persistent, I am not testing this yet.
• Change ScriptableObject to store data into text-based, e.g json, csv.
• Asset redirector, this gonna need to connect between the redirector data and the engine itself, besides the redirector needs to be compatible with the engine too.
• Script Redirector, use hash code to track any changes, basically similar to this experiment.

You can take a look at the code here.

Thank you for reading 😃 I hope you enjoy it.

Have a nice day.

Egg Farm is a relaxing mini farming game, where you can just sit and interact with everything inside the game, plant crops, and ranch animals, and design your own farm.

Since this is a mini-game there will not be many features existing, although I still add more features that seem fun.

There is still more work that needs to be done to finish this game.

The available features are planting, mill, and bee farm.

Planting

Available crops are wheat and flower, you just need to plant the seed and water it. The crops gonna grow on their own after a certain time. There is no day-night cycle in this game so you just need to wait for a while.

Mill

Build the mill to grind wheat into flour.

Bee Farm

Build a house for our little friends, and they will give us honey, but don’t forget to plant the flower.

Next Update

• Sheep ranching.

Thank you 😊 I hope you enjoy it.

Print Enum Into FString

StaticEnum<ENUM_TYPE>()->GetValueAsString(ENUM_VALUE)

Format FText

FText format = "Item Name: {ItemName}"
const FText formattedText = FText::FormatNamed(FTextFormat(format), TEXT("ItemName"), itemName);

Loop UDataTable

itemDT->ForeachRow<FItemInfo>("FindItem", [&](const FName& key, const FItemInfo& item) {
    // Do something here
});

Find a Row in UDataTable

FItemInfo* itemInfo = itemDT->FindRow<FItemInfo>(ROW_NAME, "FindItem");

Create UObject Instance

UTextBlock* text = NewObject<UTextBlock>(btn, FName("text"));

Hide Field on Certain Condition

UPROPERTY(EditAnywhere, meta=(Condition="YOUR_CONDITION", EditConditionHides))
float speed;

Create Min Max Slider for Field

UPROPERTY(EditAnywhere, meta = (ClampMin = "1", ClampMax = "10"))
int32 totalSpawned;

Instantiate a UObject/Blueprint/WBP

MyClass* instance = NewObject<MyClass>();

UPROPERTY(EditDefaultsOnly, BlueprintReadWrite)
TSubclassOf<MyClass> MyClassType;

// UObject Subclass
NewObject<ActorClass>(MyClassType);

// Actor Subclass
GetWorld()->SpawnActor<ActorClass>(MyClassType);

// Widget Subclass
MyWidget* widget = CreateWidget<MyWidget>(this, MyWidgetType);

The code above is not tested and is used for reference only.

I hope it will be helpful

Cheers 😊

I came up with two approaches.

Enum Based Localization

Because I did not have much time to make fancy tools for the localization, I decide to create a ScriptableObject to hold the localization data when the game is in the prototype phase. I use the dummy quest text I use for testing.

I assign the text one by one and add a key for the JSON, then export it into a JSON file. Besides export into JSON files, I also generate enum files using C# CodeDom. I choose to use enum because using string to get a value from the dictionary is prone to typo and will cause an error.

But as time pass and the game get more content, I figure out that this kind of system is not good, because we have many texts and the enum will get bigger too. And also because the texts are scattered in ScriptableObject, Scripts, GameObject.

I evaluated again my localization system design and found that this system design diagram is complicated. I thought of other approach and each time I come with an approach, I create another diagram to figure it how the system will look like, how they will interact with each other, how complex the system, and is it meet our need or not.

Pros

• Accessing the localization will be easier when the text amount is small.
• You can specify the key yourself.
• There should be no repetitive text in your localization.
• You have more control over which text you want to include in your localization.

Cons

• The system design is pretty complex (I believe it can be made simpler).
• You need to specify set up more keys when game text grows.
• The enum will get bigger and hard to navigate when you do not know what you want to use.
• You need to add a localization component script yourself.

**HashCode Based Localization**

Our time got more strict, We do not have much more time to find, drag and drop all the localization. I decide to use the Hash Code provided in Unity API. The hash code of the text will be taken as the key in JSON. The game itself changes from using UI Text into Text Mesh Pro because we need Text Mesh Pro features. Before diving into code, I made a diagram for the system that looks a lot simpler than the previous one.

I collected all the Text Mesh Pro components in the scene using Resources.FindObjectsOfTypeAll and write it into a JSON file, I do a similar thing for the scriptable object too, but I just drag and drop the ScriptableObject into the list in the editor and write it into JSON.

The localization files consist of a hash code of the text for its key and the text itself is the value. The game will get the localization JSON from the server. I attach the Localization Component script into each GameObject that has Text Mesh Pro. It will directly replace the Text Mesh Pro string text with the localized text using the hash code from the text in the UI.

Pros

• Fast, I do not need to set up the localization key and value, the system will automatically find it and write it into JSON.
• The localization component script is automatically attached by the system to each game object that has Text Mesh Pro.

Cons

• The key is not readable because it uses Hash Code.
• There will be similar localization that you can’t delete because it belongs to a different Instance ID.

Why not Use Existing Tools?

To be honest, I never search in the unity asset store for localization but I just knew about I2 Localization from my friends. It looks like a pretty interesting and awesome localization tool, I also knew that unity is developing its localization system.

I did not use it because I was afraid it does not meet our needs and we need time to learn it or make it meet our needs if it’s not. And when I make my own localization system I design it exactly for my games, not for general usage.

But after I take a look again at the diagram, I still can use this kind of system in my future game, after some polishing and optimization. This also helps me gain more experience in designing a modular system.

Thank you for reading my writing, I hope this is helpful.

Have a nice day :)

I want to develop and publish my own games but as time pass, I feel pretty lazy, tired especially after work. I usually work on my games in my free times.

Last year, my senior told me about Smart Framework, I read about it but I failed to really understand it. Because the article I read that time is not pretty clear and to the point for me. But today in the meeting we talk about Smart Framework and I got more understanding of that framework.

Smart stands for Specific, Measureable, Accountable, Realistic, Time-bound.

Specific

Define the What (Output, Outcome, Expected Result) and How to achieve it.

When developed an educational game for an educational game portal, the output I expected from the game was playable and ready to be submitted into the portal to be reviewed.

How I can achieve this? I will work on the game programming and the game design and art I will ask my friend to work on it. And for the sounds, we will search free to use for commercial audio.

Measurable

Define how to measure progress, the definition of done and acceptance criteria.

The definition of done from my game is when I have a playable game so I can submit my game.

Since I made this game for an educational portal, the acceptance criteria will be when my game is accepted and it performs well in that portal and generate a good amount of revenue.

And I separate the game into a smaller milestones, prototype, MVP, test, release to help me measure the progress.

Accountable

Define to whom you can delegate the goal.

You can delegate it not only to a person but to third-party services or other things too that can help you achieve your goal.

e.g when you need analytics in your game, you can use firebase analytics. Or you need history references for your history games, you can buy a history book or ask your friends that love history.

In my game, I am responsible for game programming.

Game design and art will be my friends.

The game audio will be free for commercial use audio.

Realistic

Make your goal align with your time and resources.

You should understand, how much time and resources you have.

When I worked on my educational game, my resources are 2 people with a time of 3 months. I worked on programming while my friends were in art and design. Since we only have 3 months to finish the game and I only work on it in my free time, we make the game scope smaller and pick the easiest mechanics we can implement.

The end product is considered mini-games since there is not much gameplay there. If we want to add more content or make a bigger game we will need more time or more people to work on it.

When you have a friend that working full time on his casual game and takes 3 months to finish it. You need to allocate more time when you work on a similar casual game but in your free time. A similar game scope can take different times to achieve depending on resources and time.

Time-Bound

Set the deadline for you goal.

You should give a deadline to your goal, to keep you stay motivated so you can understand if this goal is possible or not with your current time-bound. So you can adjust your resources, time, and the goal itself.

In my games, we use the deadline from the game portal which is 3 months to work on the game, make the scope small enough so you can finish it on time.

Thank you for reading this far, you are awesome.

I hope it will helpful for you.

Have a nice day :)

What is User Experience?

There are many definitions of user experience. The popular one is from Elizabeth Sanders,

Tools need to be, “Useful, Usable and Desireable”

A. Useful

The tool you make must fulfil user needs, or it will be useless. Ideally, these needs come from users & stakeholders. Before creating your tools, you must know what your user & stakeholder needs, not what they want. You need to separate which one is needs & desire. Otherwise, you will have a bunch of tasks that you need to finish and it will make the development time longer.

Let say that our studio needs a tool to manage data of the game in development. You inspect the developer activities, ask their needs and talk with the stakeholder. And you got this list of user stories.

• As a user, I want to be able to inspect the save data.
• As a user, I want to be able to change the data from the admin panel.
• As a user, I want to export the save data into a different format.
• As a user, I want to manipulate the game saved data.
• As a user, I want to change the save data in runtime.

We need to decide which one will be the needs & desire if you do all at once you will not ship your tools. Not at a short time at least, but your studio need the tools as soon as possible.

After discussion with the tools team, we decide that these are the needs. Why these? First, our tools need to show the user all the save data that the game has, otherwise it will be pointless to add more functionality when they even do not know the data. And we can provide them with functionality to manipulate the data.

• As a user, I want to be able to inspect the save data.
• As a user, I want to manipulate the game saved data.

Why we do not choose these? this feature is awesome but we still do not need it. especially for exporting the data in a different format, I think we must standardize our save data rather that support many formats since it will give a burden when maintaining it in the future. Changing save data from admin panel will be a good feature when our game is live so we can update our game from the admin panel without the need to rebuild the game. But because we are still in the development phase, we can save this for next. Save data in runtime is also a good feature especially for QA so they can easily test the game, but this feature is not needed yet now.

• As a user, I want to be able to change the data from the admin panel.
• As a user, I want to export the save data into a different format.
• As a user, I want to change the save data in runtime.

After a few days working on the main functionality, you finally come up with the basic version of your inspection tool. Now in the sprint review, you can show this and you can proud of it because you make it. And at the end of the sprint, you can ship your product to your user. And waiting for their feedback while improving the current Inspector Tool.

B. Usable

There are many definitions of usability, these definitions include a question such as.

• How efficient is it to use?

• How easy is it to learn?

• How well is the user protected from making mistakes?
• How satisfying is it to use?

In my opinion, usability itself is

Making our tool easy to use by user & reduce the chance of mistakes that happen when using the tool.

After release your Inspector Tool you get some feedback from programmer in your company that use the tool.

• This tool help me inspect the game data & I do not need to print everything
• The game getting error after I update some value
• I got confused, the list below the save button is the list of data?

Our tool already meets the needs of our user but it still not usable yet, we know it from our user feedback. First, we need to analyze the feedback and understand why this is happening.

In the feedback, we know that the user gets some error when updating the value since we are dealing with JSON file. There is a probability the user write wrong JSON syntax. Rather than show all the JSON, we can create some field that will hold the JSON data. And to make use do not confuse with the list of JSON, we can create a box area and give it a title. And we can update our Inspector Tool.

C. Desireable

The last aspect that usually feels not important or does not contribute enough to UX. However, a tool that has good aesthetic & appealing design contributes not only to user satisfaction but also will make the user believe that the designer has taken their time to create a high-quality, professional tool and make the user more confidence in using it.

To make our Inspector Tool more desireable, we can change the design of our tool and make it more eye-catching. We can separate our list of data into the left side and the right side for updating the data. Do not forget to add some good UI & colour for the tools.

Being “More Human”

The tool you make must resemble interaction with a good friend, and bad tools will make you interact with frustrating people and it will make you piss off.

Create a tool that can be a good friend for user, so they will use it because they need it. Not because they do not have any choice.

Thank you for reading this far :) hope you gain more knowledge.

And have a good day.

When you working on your game, you also want to debug, know the process of your game, take a look at the log you create for that game. It’s easy to take a look at the log in the game engine or framework, but how if I wanna look the log from the game when it already becomes executable files e.g .exe, .apk etc.

In Android, you can open a terminal and show the log cat but the experience is painful since it shows all the log from your android device too, or you can open android studio and take a look at the log cat there, but sometimes we do not need all the log from our device. We only need a specific log from the game. Or maybe simply because of the Laptop/PC is reached its limit so we can not open android studio.

At this point, we can have an in-game debug console for our games and it will be better for us if we can use it across our game. So we can reduce the time for us to make another debug console.

I will use unity in here, you can do the same idea in other frameworks/engine. In the Unity Asset Store. you can find some free and ready to use the in-game console. But my goal writing this is, I want to explore and learn how we can create our own in-game console that will fit our need. And sometimes I found my self repeating the same task when testing third-party, and it will be better when I can have debugger to help me test the third-party.

Design

The goal of the in-game console is simply displaying log from the game to us in game runtime. We need to listen to the Log Event, so each time the game is logging something we will be notified. And the log will be handled by Log Handler . The raw log will be formatted by Log Formatter and send back to Log Handler . And finally Log Handler will add the log to the ConsoleView so we can see the log from our game.

In-Game Console Design

Log Event

First we want to make sure that we can listen or subscribe to log event. So we can execute task each time an log is logged. In Unity we can subscribe to Application.logMessageReceived

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour
{

    void OnEnable()
    {
        Application.logMessageReceived += HandleLog;
    }

    void OnDisable()
    {
        Application.logMessageReceived -= HandleLog;
    }

}

Log Handler

Each time we get notify that a log is logged, we want to process that log and show it in our game console. So we need to have a method for Handle it. In Unity, we need to provide a UI for our game console that I will explain in next section.

    void HandleLog(string logString, string stackTrace, LogType type)
    {
        Debug.Log(logString);
        Debug.Log(stackTrace);
    }

The HandleLog above will be called each time our game is logging something, so we can directly process the log and show it in our game console.

Console View

We need a UI in our game to show the game logs, in Unity we can use ScrollView to solve this. We will add each log into the Console Content and to make the Vertical Scroll fit with our log list we can use ContentSizeFitter. In this Console View, I only focus on showing a short log, we can add more features in the future e.g. expand feature to see the detailed log, copy paste and send all the log to somewhere else.

Debug Console UI Hierarchy

Simple Log Console Result

Manage the GameObject

Because we will add some log text to the ScrollView we make a prefab of the log text so we can reuse it and we do not need to setup it from script. We only need to setup the prefab once and we can use it all the time.

While creating this in-game console, I also created in-game debugger so we can add some button and inspect some value using text. And this console is also a part of the debugger.

Thank you for reading my post :) Have a nice day.

You can check the code in github