Category: GameDev

• [Unreal] Packaging issue fix

  I have been doing some research on common Unreal related mistake for Unreal beginners. Going to start making posts about the find and solution.
  
  Packaging issue:

  • Not having game solution
    • That is a must for C++ project. People might be able to by pass that somehow but that is never a recommendation. Generate your solution. You can do that from right clicking the .uproject file or just do it from editor
    • 
  • Engine integrity issue
    • Fix: go to Epic Games Launcher and verify your engine
    • 
    • What does it cause?
      • When you look at your UE5 solution and you can’t build UE5, that means your game project lost the proper reference to the engine. It still “works” but when you compile it, it could fail to build proper binary for packaging
      • Example for working project:
    • What caused this?
      • This is an super old issue exist in UE4 or older(usually for C++ projects), can be caused by many reasons. Unreal is just that sensitive.
  • Wrong target file
    • Under your root for game project, under Binaries\Win64, you will see <GameProjectName>Editor.target. However, when building, you need <GameProjectName>-<Platform>-<Config>.target
    • And you can generate that from building your game project with the platform and config you want to use, which UE5 integrity is required
    • On that note, I recommend get use to pack for shipping config so you don’t ended up having a development or debug installer that is slow

  October 10, 2025

  Unreal

  ---

• [Dev Log] save system V0.1

  Got a pretty interesting surprise today when I started working on the project. For some reason my github is corrupted. I did some research and ended up removing and adding my origin back. Not sure why the head became null out of no where…but then after that I finally got to complete the first iteration of the high level game loop and move on to the save system.

  When you load the game, you need to have a few information:

  • name of the scene
  • player data
    • health, mana
    • current location
    • state
  • item data
    • With their specific information

  More is needed for saving:

  • save time
  • progress (ex. chapter 3 – 1)
  • name of the save

  The class that holds the information above should use attribute [System.Serializable] since we are using the JsonUtility in Unity. Using ToJson and FromJason can easily turn the class into text format. I choose to have a static member of save data to carry them across the scene. We have all the scene script derived from a base scene script. It will be nice if we can define the load function callback in the base script’s awake, and have the base call it. Unfortunately, Unity’s C# behave a little bit different and won’t do that. Seems like we will have to either have all the scene script do their own loading function in Awake or call it in Awake, or having the base class do it in its own Awake and make sure the child always call base.Awake() as the first line.

  Not all the scene needs to load data, so having each scene handles the data is probably what we are going to do…however, it will be nice if we can clean the save data after we are done loading. We could use an in-game MonoBehaviour to track it, but that means we need another actor/component in every scene. Something I want to try is a clean-up-after-yourself approach. When the save data got taken, it should clean it self after it. When all the data got cleaned, we know all the loading has happened and it can wipe itself after that. Right now it works without thinking about the loaded data, meaning it might have trouble when finishing a game and move into next level. The next step will be implementing that system.

  June 21, 2025

  coding, programming, Unity

  ---

• Unity notes

  • Macro: nameof(functionName) returns a string, which is the same for just doing “functionName”, but it is safer.
    • It is safer because we can change our function name in future. If we are using a normal string, it will compile and lose the ability to know that it needs to change. On the other hand, nameof() method will fail as the parameter is no longer valid.
  • Often used specifiers:
    • For member:
      • [Header(“catagory”)]
      • [Min(value)]
      • [Max(value)]
      • [Space]
      • [SerializeField]
      • [Tooltip(“tool tip”)]
      • [HideInInspector]
    • For class:
      • [RequireComponent(typeof(class))]
      • [System.Serializable]
        • Make sure you have this if you want to have this class editable in Unity editor
    • For function:
      • [SettingsProvider]
  • To create a custom project setting, make a class from ScriptableObject with the target variable with [SerializeField]
    • In your class, create a const string with the path of the asset for you setting
    • Create functions to create/save setting
    • Create another class from SettingsProvider, with a SerializedObject as member
    • Override the OnGUI function and use EditorGUILayout.PropertyField and call FindProperty on your SerializedObject to make the property on the project setting UI, followed by ApplyModifiedPropertiesWithoutUndo
    • EditorGUILayout.PropertyField(CustomSettings.FindProperty(“SettingName”));
    • Create a function that returns your SettingsProvider and use [SettingsProvider] on the function
  • When you have C++ DLL for unity project, Unity won’t be able to recover from critical errors like how it handles it in C#
    • The crash log and dump will be stored at this location: C:\Users\<username>\AppData\Local\Temp\Unity\Editor\Crashes\
  • In the situation where there are static data for the scene and you are loading scene asynchronously. The game might have issue as the static data will be polluted.
    • The solution for this is create a buffer map, something like loading map to load between the 2 scenes. To make sure the new map will be loaded after the old map unloaded
  • OnValidate is called when member got modified in editor, and when entering play/editor mode against default value. The latter might need to be avoid
    • you can have a bool to mark if OnValidate is called or not
    • use EditorApplication.isPlaying and EditorApplication.isPlayingOrWillChangePlaymode to prevent the logic being called during play mode
  • LineRenderer can only do 1 line, but it can do a lot of nodes
    • When want to render more than 1 line, you can use multiple game object with LineRenderer component or have the 1 LineRenderer component render a long line like embroidery
  • When doing singleton, don’t do it in constructor (That is what you should do in C++, but not Unity)
    • Do it in Awake function

  June 20, 2025

  c, coding, programming, software, technology, Unity

  ---

• [Dev Log] pick-a-path map generation

  In the past few days, I have been working on sorting out the functional needs for the RTS Rogue-like game. We eventually decided to make a path picking system like FTL or Slay the Spire. It is an important system for balancing strategic planning with the replayable chaos that makes roguelikes fun.

  I wanted players to navigate through a branching network of nodes, each representing a mission. The player chooses a path through this map, picking missions that align with their resources, army composition, or long-term strategy. Unlike card battlers, RTS missions are longer and more intense — so every node needed to matter.

  To capture this, I aimed for a tiered layout with a clear top-down flow. Each tier has several nodes, and each node can connect to one or multiple nodes in the next tier. This structure balances randomness with control: the player is never fully at the mercy of RNG, but still gets surprises and tactical choices.

  The system allow to set rules–for example, the first and the last tier will only have 1 node since they are the beginning and the ending. We also give each node count its own probabilities so we can shape the map based on other settings. Another rule we added is not allowing one node tier to be followed by another one node tier, since it practically removes the point of having a selection map like this. To make the map dynamic and versatile, all the parameters are adjustable, from the number of tiers to min/max number of nodes allowed.

  Here’s how the system works:

  • Fixed number of tiers: For example, 6 rows of nodes.
  • Each tier has 2-4 nodes: Chosen randomly within a max width.
  • Connections are constrained: Each node connects only to nodes in the next tier, ideally 1-3 downstream connections.
  • Guaranteed reachability: Every node must be reachable from the start, and all path must always lead to the final node.

  This is just a working prototype. The next step is to create the scene that will connect to/be connected from this path-picking map.

  June 17, 2025

  programming, Unity

  ---