EllanJiang/GameFramework

GameFramework is a Unity-based game development framework that provides a comprehensive suite of modular utilities for building games. It offers specialized systems for managing game states, resources, and data, including finite state machines, object pooling, and hierarchical data management. The framework also handles core gameplay infrastructure such as network communication, sound, UI, and localization, while providing foundational tools like logging, event handling, and configuration management.

25 changes.

This period marks the initial release of the Game Framework, a Unity-based game development toolkit. The work introduced a comprehensive suite of 19 built-in modules, including systems for entity management, finite state machines, object pooling, and resource handling, establishing the core architecture for the project.

6 changes.

This period focused on establishing a robust, modular foundation for the Game Framework by introducing dedicated managers for configuration, versioning, logging, and data assets. The team standardized interfaces and data structures to support custom implementations and improve type safety across the system.

The GameFramework library now includes a new event management system. This introduces the \IEventManager\ interface and its \EventManager\ implementation, which provide methods for subscribing to, unsubscribing from, and firing events. The system supports a default event handler, allows multiple handlers per event ID, and offers both asynchronous (next-frame) and synchronous (immediate) event firing modes.

GameFramework/Event · high confidence

The Finite State Machine (FSM) system has been added to the Game Framework. This includes the core FSM implementation, state management, and a dedicated FSM manager for creating, retrieving, and destroying state machines. The API provides methods to manage state transitions, access state data, and query the status of active state machines.

GameFramework/Fsm · high confidence

This entry marks the initial commit of the Game Framework, a Unity-based game development framework. The repository introduces the core solution file (GameFramework.sln) configured for Visual Studio 2019, along with a comprehensive README.md documenting 19 built-in modules including Config, Data Node, Data Table, Debugger, Download, Entity, Event, File System, FSM, Localization, Network, Object Pool, Procedure, Resource, Scene, Setting, Sound, UI, and Web Request. The project also includes a .gitignore file tailored for Visual Studio and .NET development environments, and updates the LICENSE file to reflect the 2013-2021 copyright period.

(repo-wide) · high confidence

The GameFramework library is introduced as a new component, providing a comprehensive set of utilities for game development. This includes core base classes, a task pool, configuration and data table managers, a download manager, entity management, event handling, a finite state machine system, localization support, network channels, object pooling, and a file system abstraction. The project file targets .NET Framework 3.5 and includes all associated C\# source files for these modules.

(dependencies) · high confidence

Added a new DataNode system within the GameFramework, providing a hierarchical structure for managing data nodes. This includes the \IDataNode\ and \IDataNodeManager\ interfaces, along with the \DataNodeManager\ implementation, enabling users to create, retrieve, and manipulate data nodes using path-based access and parent-child relationships.

GameFramework/DataNode · high confidence

The Game Framework adds a new debugger subsystem consisting of the \DebuggerManager\ and \DebuggerWindowGroup\ classes, along with their corresponding interfaces (\IDebuggerManager\, \IDebuggerWindow\, \IDebuggerWindowGroup\). This change introduces the ability to register, unregister, and select debugger windows via a hierarchical path system, allowing developers to manage and interact with various debugging tools within the framework.

GameFramework/Debugger · high confidence

Added the EventPool component, including the BaseEventArgs class, EventPool implementation, and EventPoolMode configuration, to provide a new mechanism for managing and dispatching events within the game framework.

GameFramework/Base/EventPool · high confidence

The ObjectPool module is introduced, providing a new object pooling system with interfaces (IObjectPool, IObjectPoolManager) and implementations for managing object lifecycles. The implementation includes memory allocation optimizations, such as using \[StructLayout(LayoutKind.Auto)\] for the ObjectInfo struct and optimizing string concatenation to reduce GCAlloc. The system supports creating single or multi-spawn object pools, managing object states (locked, priority, expiration), and provides filtering callbacks for object release.

GameFramework/ObjectPool · high confidence

A new TaskPool system has been added to the Game Framework, providing a mechanism to manage and execute tasks with support for priority, tags, and user-defined data. The update introduces core components including the TaskPool class, which handles task scheduling and agent management, along with supporting types such as TaskBase, TaskInfo, and enumerations for TaskStatus and StartTaskStatus. This allows users to track, query, and control the state of running and waiting tasks within the framework.

GameFramework/Base/TaskPool · high confidence

Added a new internal struct, TypeNamePair, which combines a .NET Type with a name string. This struct implements value equality and hashing, providing a more efficient and type-safe way to represent type-name pairs within the Game Framework's data structures.

GameFramework/Base/DataStruct · high confidence

A new WebRequest module has been added to the Game Framework, providing a complete system for managing HTTP requests. This includes the \WebRequestManager\ to handle task pooling, agent management, and event broadcasting (start, success, failure). The module supports adding requests with URIs, post data, tags, priorities, and custom user data. It also exposes status information about the request queue and agents, allowing developers to monitor and control network activity within the framework.

GameFramework/WebRequest · high confidence

Added the abstract base class Variable and its generic counterpart Variable\<T\> in the GameFramework/Base/Variable directory. These classes provide a standardized interface for managing variable values, including methods to get, set, and clear values, as well as retrieving the variable's type. This establishes a foundational component for handling typed variables within the framework.

GameFramework/Base/Variable · high confidence

A new global configuration module has been added to the framework, providing a dedicated manager for storing and retrieving global configuration values of type bool, int, float, and string. The system supports adding, removing, and querying configuration items, and exposes events for read success, failure, and updates. This new component allows developers to manage global settings through a clean API.

GameFramework/Config · high confidence

The DataTable module has been refactored to support loading data tables from binary resources, enabling 'play while downloading' scenarios. The update introduces new interfaces (IDataRow, IDataTable, IDataTableManager) and a base class (DataTableBase) that facilitate this. For users, this means data tables can now be loaded via binary streams, and the system provides optimized memory allocation to reduce garbage collection (GC) overhead. The API exposes methods to ensure cached binary stream sizes and free cached bytes, offering better control over memory usage during data table operations.

GameFramework/DataTable · high confidence

Added a new File System module to the Game Framework, including the core \FileSystem\ implementation, a \FileSystemManager\ for managing multiple file systems, and supporting types such as \FileInfo\, \FileSystemStream\, and \IFileSystem\/\IFileSystemManager\/\IFileSystemHelper\ interfaces. This provides a unified API for creating, loading, and reading/writing files within the framework.

GameFramework/FileSystem · high confidence

Added the core components for the new procedure management system in the GameFramework. This includes the IProcedureManager interface, the ProcedureBase abstract class for defining game states, and the ProcedureManager implementation which handles initializing, starting, and querying the current state of game procedures via a finite state machine.

GameFramework/Procedure · high confidence

The localization module has been refactored to support a new \Language\ enum containing over 40 supported languages, allowing users to dynamically switch the application's display language. The \ILocalizationManager\ interface and \LocalizationManager\ implementation now provide a comprehensive API for managing localization dictionaries, including retrieving string content by key with support for up to seven template arguments. The system also introduces a \SystemLanguage\ property to automatically detect the device's native language, and exposes events for read success, failure, and updates, enabling robust handling of localization data loading and error states.

GameFramework/Localization · high confidence

The GameFramework/Scene area introduces a new \ISceneManager\ interface and a suite of event argument classes (\LoadSceneSuccessEventArgs\, \LoadSceneFailureEventArgs\, \LoadSceneUpdateEventArgs\, \LoadSceneDependencyAssetEventArgs\, \UnloadSceneSuccessEventArgs\, \UnloadSceneFailureEventArgs\) to handle scene lifecycle events. This provides a structured way to monitor and react to scene loading, updating, and unloading states within the framework.

GameFramework/Scene · high confidence

The sound module has been completely refactored with a new architecture, introducing interfaces for sound managers, groups, and agents. Users can now control sound playback with features like fade-in/fade-out effects, adjustable pitch, stereo panning, spatial blending, and Doppler effects. The API provides granular control over volume, mute states, loop status, and priority, while exposing events for success, failure, and update progress during sound playback.

GameFramework/Sound · high confidence

Added the \ISettingHelper\ and \ISettingManager\ interfaces, along with the \SettingManager\ implementation, to provide a non-generic API for managing game settings. This includes methods for loading, saving, and querying configuration values of various types (bool, int, float, string, and generic objects).

GameFramework/Setting · high confidence

Adds foundational components to the Game Framework, including the \GameFrameworkEntry\ class for module lifecycle management, \GameFrameworkModule\ as the abstract base for all modules, and utility classes such as \GameFrameworkLinkedList\, \GameFrameworkMultiDictionary\, and \GameFrameworkSerializer\. This also includes generic delegate types (\GameFrameworkAction\, \GameFrameworkFunc\) and event argument structures to support the framework's internal architecture.

GameFramework/Base · high confidence

The Game Framework now includes a ReferencePool system located in the Base/ReferencePool directory. This feature introduces an object pooling mechanism that allows developers to acquire and release reusable object instances, helping to reduce memory allocation overhead. The implementation includes the IReference interface, a ReferenceCollection internal class for managing pools, and a static ReferencePool class providing methods like Acquire, Release, Add, and Remove. Additionally, a ReferencePoolInfo struct is provided to expose statistics such as unused, using, acquire, release, add, and remove counts for each pooled type, facilitating debugging and performance monitoring.

GameFramework/Base/ReferencePool · high confidence

A new DataProvider system has been introduced to handle loading, parsing, and managing data assets. This includes the \DataProvider\<T\>\ implementation, a \DataProviderCreator\ for instantiation, and the \IDataProvider\<T\>\ and \IDataProviderHelper\<T\>\ interfaces. The update also adds event argument classes (\ReadDataSuccessEventArgs\, \ReadDataFailureEventArgs\, \ReadDataUpdateEventArgs\, \ReadDataDependencyAssetEventArgs\) to report loading progress, success, failure, and dependency asset states to the user.

GameFramework/Base/DataProvider · high confidence

The download module has been refactored to support pausing downloads, assigning task priorities, and downloading files larger than 2GB. The \DownloadManager\ now exposes a \Paused\ property to suspend all downloads, and the \TaskPool\ mechanism has been optimized to handle task priorities and status tracking. Additionally, the download speed statistics have been updated to calculate a 30-second average, and the module now supports retrieving user-defined data and task status information.

GameFramework/Download · high confidence

The versioning system now uses a pluggable helper interface (IVersionHelper) to retrieve game version details. This allows the application to provide custom version information through the SetVersionHelper method, while the framework itself exposes a static GameFrameworkVersion string (2021.05.31).

GameFramework/Base/Version · high confidence

The network module has been restructured to use a new set of interfaces (INetworkChannel, INetworkManager, etc.) and event-driven error handling. This introduces a more flexible architecture where each network channel can independently register packet handlers, support custom packet headers, and expose detailed error codes (NetworkErrorCode) and socket-specific errors via new event args (NetworkErrorEventArgs, NetworkCustomErrorEventArgs). The change also includes a new AddressFamily enum and helper interfaces to improve usability and reduce memory allocations.

GameFramework/Network · high confidence

The entity and interface modules have been refactored to optimize memory allocation and reduce garbage collection (GC) overhead. This includes replacing LinkedList with List in several areas, optimizing string concatenation and comparison logic, and adjusting the entity serial number increment rules to avoid using 0. Additionally, the code has been updated to be compatible with lower versions of the compiler by replacing specific invocation syntax, and various bugs related to entity release and state checks have been fixed.

GameFramework/Entity · medium confidence

The logging subsystem in GameFramework/Base/Log has been refactored to allow custom log implementations. A new ILogHelper interface and a SetLogHelper method have been added to GameFrameworkLog, enabling developers to inject their own logging logic. The previous DebugLog conditional compilation directive has been removed, and the log level enum now explicitly defines Debug, Info, Warning, Error, and Fatal levels.

GameFramework/Base/Log · high confidence

The UI module has been refactored to introduce new interfaces (IUIForm, IUIGroup, IUIManager) and associated event argument classes (OpenUIFormSuccessEventArgs, OpenUIFormFailureEventArgs, etc.) to manage UI forms and groups. This change restructures how UI forms are created, tracked, and recycled, providing a more robust and extensible API for handling UI state changes, loading progress, and dependency assets.

GameFramework/UI · high confidence

The GameFramework/Utility namespace has been restructured to support pluggable helper implementations for compression, JSON serialization, and text formatting, each exposed via a dedicated interface (ICompressionHelper, IJsonHelper, ITextHelper) that can be set via Set\*Helper methods. The existing utility classes (Assembly, Converter, Encryption, Marshal, Path, Random) have been reorganized into separate files, with the text formatting logic now delegating to the configured ITextHelper or falling back to string.Format. Additionally, unused code such as CombinePath and MD5 has been removed, and performance optimizations including reduced GC allocation and improved string handling have been applied.

GameFramework/Utility · medium confidence

The resource module has been refactored to replace event-based completion notifications with explicit callback functions, introducing new callback classes such as LoadAssetCallbacks, LoadBinaryCallbacks, and LoadSceneCallbacks to handle success, failure, and update states. Additionally, new interfaces IResourceGroup and IResourceGroupCollection have been added to manage resource groups and their aggregate states, while supporting binary resources and optimized memory allocation throughout the loading process.

GameFramework/Resource · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 42 → 42 (-0.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 87 → 83 (-4.2)
• Architecture 68 → 68 (-0.3)
• Maturity 42 → 41 (-1.1)
• Readiness 23 → 23 (+0.0)
• Security 95 → 95 (+0.0)
• Performance 70 → 70 (+0.0)

• Build did not complete in the analyzer
• Change coupling: CheckResourcesCompleteCallback.cs ↔ ResourceManager.cs (GameFramework/Resource/CheckResourcesCompleteCallback.cs)
• Change coupling: IConfigHelper.cs ↔ ILocalizationHelper.cs (GameFramework/Config/IConfigHelper.cs)
• Change coupling: IResourceManager.cs ↔ UpdateResourcesCompleteCallback.cs (GameFramework/Resource/IResourceManager.cs)
• Change coupling: ResourceManager.cs ↔ UpdateResourcesCompleteCallback.cs (GameFramework/Resource/ResourceManager.cs)
• Duplicated block (11 lines × 2) (GameFramework/Resource/ResourceManager.cs)
• Duplicated block (14 lines × 2) (GameFramework/Network/NetworkManager.TcpNetworkChannel.cs)
• Duplicated block (15 lines × 2) (GameFramework/Network/NetworkManager.TcpNetworkChannel.cs)
• Duplicated block (15 lines × 2) (GameFramework/Network/NetworkManager.TcpNetworkChannel.cs)
• Duplicated block (15 lines × 2) (GameFramework/Resource/ResourceManager.ResourceChecker.cs)
• Duplicated block (18 lines × 2) (GameFramework/Network/NetworkManager.TcpNetworkChannel.cs)
• Duplicated block (25 lines × 2) (GameFramework/Network/NetworkManager.TcpNetworkChannel.cs)
• Duplicated block (7 lines × 2) (GameFramework/Resource/ResourceManager.ResourceVerifier.cs)
• Duplicated block (8 lines × 2) (GameFramework/FileSystem/FileSystem.cs)
• High interface indirection
• No exposed public API
• dormant codebase — no living knowledge left to concentrate
• redundant comment (GameFramework/Base/DataProvider/IDataProviderHelper.cs)

• Change coupling: ConfigManager.cs ↔ ILocalizationManager.cs (GameFramework/Config/ConfigManager.cs)
• Change coupling: IConfigManager.cs ↔ ILocalizationManager.cs (GameFramework/Config/IConfigManager.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (GameFramework/Resource/ResourceManager.ResourceGroup.cs)
• Duplicated block (11 lines × 2) (GameFramework/Resource/ResourceManager.ResourceChecker.cs)
• Duplicated block (11 lines × 2) (GameFramework/Resource/ResourceManager.ResourceChecker.cs)
• Duplicated block (11 lines × 2) (GameFramework/Resource/ResourceManager.ResourceUpdater.cs)
• Duplicated block (11 lines × 3) (GameFramework/Resource/ResourceManager.ResourceUpdater.cs)
• Duplicated block (12 lines × 2) (GameFramework/Sound/PlaySoundParams.cs)
• Duplicated block (13 lines × 2) (GameFramework/Resource/PackageVersionList.cs)
• Duplicated block (13 lines × 2) (GameFramework/Resource/ResourceManager.ResourceGroup.cs)
• Duplicated block (13 lines × 2) (GameFramework/Resource/ResourceManager.ResourceGroup.cs)
• Duplicated block (13 lines × 2) (GameFramework/Resource/ResourceManager.ResourceGroup.cs)
• Duplicated block (13 lines × 3) (GameFramework/Resource/ResourceManager.cs)
• Duplicated block (14 lines × 2) (GameFramework/Network/NetworkManager.TcpNetworkChannel.cs)
• Duplicated block (14 lines × 4) (GameFramework/Network/NetworkManager.TcpNetworkChannel.cs)
• Duplicated block (16 lines × 2) (GameFramework/Resource/ResourceManager.ResourceUpdater.cs)
• Duplicated block (16 lines × 2) (GameFramework/Resource/ResourceManager.cs)
• Duplicated block (17 lines × 2) (GameFramework/Network/NetworkManager.ReceiveState.cs)
• …and 28 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

EllanJiang/GameFramework was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.