JKFrame 2.0

JKFrame 2.0 is a toolkit designed for indie game developers and small teams. Rather than a rigid framework requiring extensive inheritance, it functions as a toolbox where most features are optional and behave like plugins. You can use specific systems without being forced to implement their interfaces or inherit from their classes.

Key characteristics:

• Toolkit Approach: Most features are decoupled and can be used as needed.
• Plugin-like Functionality: Systems like SaveSystem and AudioSystem can be called directly.
• Built-in Dependencies: Includes support for the Odin Inspector plugin for enhanced serialization and debugging, and JKLog for logging.

The Resource System manages the acquisition, asynchronous loading, and unloading of Unity resources, GameObjects, and class objects.

Performance Optimization: When requesting a resource, the system first checks the corresponding Object Pool (GOP or OP). It only performs a standard resource load/instantiation if the pool is empty or does not exist.

Supported Versions:

• Resources version: Associates object pools with standard Unity Resources loading/unloading.
• Addressables version: Associates object pools with Addressables. It includes integration with event tools to automatically call Addressables.Unload when a GameObject is destroyed.

You can switch between these versions in the framework settings.

The UI framework maintains a central registry of all windows in a Dictionary<string, UIWindowData>.

Each UIWindowData entry contains:

• isCache: Boolean indicating if the window should be pooled/reused.
• assetPath: The resource location (Addressables or Resources).
• layerNum: The rendering priority.
• instance: The actual active UI_WindowBase instance (null if not currently instantiated).

By using a windowKey instead of a raw file path as the index, the framework allows multiple distinct window instances to share the same underlying prefab/class resource.

The Object Pool system reduces performance overhead and Garbage Collection (GC) by reusing instances instead of frequent Instantiate and Destroy calls.

JKFrame provides two types of pools:

1. GameObject Pool (GOP): Manages GameObject instances that exist in the scene (visible in Hierarchy).
2. Object Pool (OP): Manages non-scene objects like C# classes or material resources.

Key Features:

• Capacity Limits: You can set a maxCapacity. If the pool exceeds this limit, new objects being returned to the pool will be Destroyed instead of stored.
• Pre-warming: You can specify a defaultQuantity during initialization to instantiate and fill the pool with objects immediately.
• Global vs. Local: Most users should use the global PoolSystem. However, you can build custom pools by holding a PoolModule layer.

The framework implements a layer management system with built-in masking (Mask).

• Masking Behavior: By default, layers are stacked. If a window is active in a layer, all layers below it are non-interactive. Within the same layer, only the most recently opened window is interactive, ensuring only one window per layer is active at a time.
• Disabling Masks: You can uncheck the mask option in the UISystem panel to allow interaction across layers.
• Drag Layer: A special top-level layer called dragLayer is provided for temporary UI placement during drag operations. Access it via UISystem.dragLayer.

Beyond the core systems, JKFrame includes several utility tools:

• State Machine: For managing script logic states.
• Event Tool: Binds events like Collision, Trigger, Click, Drag, and custom events to objects.
• Coroutine Tool: Optimized coroutines designed to avoid Garbage Collection (GC).
• Excel and ScriptableObject Converter: Enables conversion between Excel and Unity assets (Prefabs, Sprites, etc.). It supports GUID mode (allowing prefab path changes without breaking references) and SubAsset support (e.g., sliced sprites).

The localization system is extensible. You can add support for new asset types (like AudioClips) by inheriting from LocalizationDataBase and implementing a new data class.

Implementation Steps:

1. Create a new class inheriting from LocalizationDataBase.
2. Add the desired fields (e.g., public AudioClip content;).
3. Use LocalizationSystem.GetContent<YourNewClass>(key, languageType) to retrieve it.

Example: Adding Weapon Data

public class LocalizationWeaponData : LocalizationDataBase
{
    public string content;
    public string type;
}

// Example of a custom data class for localization
public class LocalizationWeaponData : LocalizationDataBase
{
    public string content;
    public string type;
}

To ensure compatibility with the save system, the framework provides specialized serialized versions of common Unity/C# types. These wrappers handle the conversion between complex types (like Dictionaries) and simple serializable structures (like Lists).

• Dictionary: Serialized_Dic (automatically splits into a List for serialization and reconstructs the Dictionary on load).
• Vector: Serialized_Vector2, Serialized_Vector3 (stores only x, y, z coordinates).
• Color: Serialized_Color (stores only r, g, b, a).

Usage: Replace your standard type declarations with these serialized versions. The framework overloads assignment operators and type conversion methods, allowing them to work seamlessly with native Unity types.