HTFramework
v0.4.1
HTFramework is a fast development framework based on Unity, integrating modularity of requirements, code reusability, practical convenience, high cohesion of functions, unified coding specifications, scalability, maintainability, versatility, and pluggability. , and provide continuous maintenance and upgrades.
Unity version: 2022.3.34.
.NET API version: .NET Framework.
AspectTrack - A section-oriented program code tracking module according to the AOP idea architecture. It can track the call of each method, block the method before it is called, or change its incoming arguments, change its return value, etc.! It can be used for call log printing, system operation monitoring and other requirements.
Audio - Manager of all audio in the project, providing a unified interface for playing, pausing, and stopping various audio resources.
Controller - encapsulates protagonist control, main camera control, etc., simplifies a lot of repeated code.
Coroutiner - Coroutiner scheduler. Coroutiner started by coroutiner scheduler will be under monitoring of the scheduler. You can view the running status and time-consuming of coroutiner through the CoroutinerTracker tracking panel. You can restart and terminate any coroutiner.
CustomModule - The framework has multiple commonly used modules built in. If you want to add your own module, you can add custom modules through CustomModule. Custom modules have the same life cycle as built-in modules.
DataSet - Custom data sets. Any place where data is needed can be defined as a custom data set, including prefabricated configuration files, dynamic data generated at runtime, various data pulled from the background, etc.
Debug - Debug module comes with Debugger runtime debugger, which can monitor some regular data and software running environment, or perform some advanced operations, such as retrieving all game objects in the scene (equivalent to the function of the Hierarchy window in the editor), and searching All components of the game object (equivalent to the functionality of the Inspector window in the editor).
ECS - Entity-Component-System. This ECS is not Unity ECS, which does not necessarily bring about performance improvements. It is based on the idea of ECS and is based on Unity's existing component model. Developing in the ECS model can avoid it. The heavy inheritance chain in the later stage of the project improves development speed and quality, as well as project stability.
Entity - Entity manager. Except for the UI, the other visible objects in the scene should be abstracted into Entity. It will be a good match for managing logic with FSM on Entity.
Event - All operations can be defined as specific global events, and the entire business logic can be driven by subscribing to events and throwing events.
Exception - Exception handler, when an unknown or uncaught exception occurs in any part of the program, it will be intercepted here and write to the log file. It also supports opening the specified program when the exception occurs (only on the PC platform), or in When an exception occurs, the log is returned to the specified mailbox.
FSM - simulates all business logic that can be abstracted into a finite state machine structure, similar to character animation, monster AI, any individual with independent logic, etc.
Hotfix - A lightweight thermal update framework implemented with C# reflection. It is very convenient to develop. New projects only need to pull the framework source code and create a hot update environment with one click. After that, it can be developed normally with C#. It is currently supported in hot Update any method to dynamically repair the outside world in the library without releasing the project.
Input - Defining any input as a virtual input and then calling it uniformly by the Input module will be the optimal solution for cross-platform input.
Instruction - Instruction system that can compile and execute arbitrary instruction code at runtime to achieve the fastest patching function.
Main - The main framework module provides a shortcut interface to access other modules, and also supports quick setting script definition, specifying global main data classes, setting project authorization, and configuring global parameters.
Network - Network client module, in a single communication pipeline, each pipeline supports TCP/UDP and other protocols, can define communication message formats for each pipeline, and can basically be competent for some common communication environments.
ObjectPool - A dedicated object pool for GameObject type. You can reuse any GameObject object to reduce the overhead of the system when frequently creating and deleting objects.
Procedure - Process is the core module of the framework and the most basic module. It runs through the entire framework, from the beginning of the framework's life cycle to the end of the life cycle, it will be completed between the processes. At the same time, it is a limited edition of enhanced version. A state machine, when switching between multiple processes until the final process, represents the end of the entire system.
ReferencePool - An object pool that can be used for any reference type (except GameObject). Any reference type objects can be reused to reduce the overhead of the system when frequently creating and deleting objects.
Resource - Resource Loading Manager, mainly used for dynamic loading of resources (only supports asynchronous loading). Custom operations can be performed during loading or after loading. Now it mainly supports Resource loading mode, AssetBundle loading mode, Addressables loading mode, such as , the UI module will automatically call the explorer to load the UI entity.
StepMaster - Step Editor. Strictly speaking, StepEditor is just a built-in tool for the framework. Its initial purpose was to solve a series of lengthy linear tasks. In order to visualize and reduce the complexity of later changes, of course, it can also be used. As a flow controller.
TaskMaster - Task Editor, which can customize task points, set the conditions for task completion, and multiple task points form a task content, and use a series of task content to complete the role-playing design.
UI - UI entities used to manage the global, so as to eliminate a series of operations such as manually creating UI instances and destroying UI instances. It can enable you to organize and control regulations clearly with the advantages of very convenient and unnecessary overhead. Any complex UI structure.
Utility - Framework utility, including some batch processing tools and editor tools.
WebRequest - Network request module, mainly used to communicate with web servers, such as requesting a certain network link or server interface, obtaining reply or downloading resources on the network.
AI [Optional Module] - AI-related modules, such as A* pathfinding and various artificial intelligence modules.
Deployment [Optional Module] - Lightweight resource deployment pipeline, integrating resource packaging, resource version construction, and resource version update to quickly realize resource deployment and delivery games.
GameComponent [Optional Module] - Game Component Module, This module integrates multiple subsystems or components that may be involved in the game development process, including but not limited to file systems, localization systems, novices boot systems, time systems, AVG2D Systems, FTG2D systems, RPG2D systems, etc., and each system or component is pluggable. Unwanted systems or components can be removed with one click, or imported with one click.
AssetBundle Browser 1.7.0.
Dotween Free 1.2.632.
LitJson 0.17.0.
Entry-level demo.
Application-Level Demo - Super Tank War.
Application-level Demo - FTG2D horizontal version of free fighting.
Application-level Demo - RPG2D role-playing and turn-based chess.
1. All functions starting with On in the framework are life cycle functions or callback functions, and are called by the framework. Please do not call them manually.
2. The Procedure in the framework must contain at least one process to correctly build the project, while other modules, if not required, can be used.
1. The entrance scene is the beginning of everything and the end of everything. The entire life cycle of the game will be completed in the entrance scene. It is not recommended to use the multi-scene switching mode. If you really need to use it, you can put other scenes into the AB package. load.
2. The entrance scene only contains the framework main module (or other custom main modules, main controllers), and anything else should be loaded dynamically.
Addressables - Access to Addressables addressable system.
Assets Master - Asset Manager, allows you to view and manage assets that are of interest to you in the edit mode or run mode very intuitively.
Code Snippet Executer - Editor tool for code snippet testing and unit testing.
HybridCLR - Access to HybridCLR hot update.
Inspector - supports the simple addition of feature tags to serialize fields to achieve customization of various practical viewer effects on the Inspector interface.
License - The authorization verification function supports the execution of the specified authorization check when your game is started. It can be a local authorization check or a remote authorization check. Only when the authorization check passes can you enter the game normally. If the authorization check fails, the framework will be paralyzed. The entire program, no matter what remedy the user makes, will be futile.
Markdown Text - MarkdownText is an extended enhanced version of Text, which supports parsing and displaying Markdown format text at runtime.
MVVM - Data-driven mode of UI.
Scene Handler - supports the customization of multiple practical handles on the Scene interface by simply adding feature tags to the serialized fields.
Settings - The Global Settings Panel can quickly and uniformly set some global parameters, and can also customize settings to set any of your own game parameters.
Table View - Use TableView to draw table views in the editor very conveniently.
Control Inversion - Use Control Inversion mode in Unity.
Standardized naming - Establish a unified standardized naming specification.
1. Pull the frame into the Assets folder in the project (Assets/HTFramework/), or add submodules.
2. Right-click in the Hierarchy view of the entry scene, select HTFramework -> Main Environment, and delete other things in the entry scene (except for the main module of the framework, anything else should be dynamically loaded. ).
3. Refer to the help documents of each module to start development.
